@purpleschool/multisite 0.0.1 → 0.0.3

package/build/commands/auth/register.command.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare namespace RegisterCommand {
+    const RequestSchema: z.ZodObject<Pick<{
+        uuid: z.ZodOptional<z.ZodString>;
+        siteId: z.ZodOptional<z.ZodString>;
+        email: z.ZodString;
+        password: z.ZodString;
+        role: z.ZodOptional<z.ZodNativeEnum<typeof import("../..").USER_ROLE>>;
+        status: z.ZodOptional<z.ZodNativeEnum<typeof import("../..").USER_STATUS>>;
+    }, "email" | "password"> & {
+        partnerId: z.ZodOptional<z.ZodString>;
+        marketingConsent: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        password: string;
+        marketingConsent: boolean;
+        partnerId?: string | undefined;
+    }, {
+        email: string;
+        password: string;
+        partnerId?: string | undefined;
+        marketingConsent?: boolean | undefined;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            accessToken: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            accessToken: string;
+        }, {
+            accessToken: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            accessToken: string;
+        };
+    }, {
+        data: {
+            accessToken: string;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=register.command.d.ts.map

package/build/commands/auth/register.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.command.d.ts","sourceRoot":"","sources":["../../../commands/auth/register.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,eAAe,CAAC;IACtB,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;MAMxB,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/commands/auth/register.command.js

@@ -8,6 +8,9 @@ var RegisterCommand;
     RegisterCommand.RequestSchema = models_1.UserSchema.pick({
         email: true,
         password: true,
+    }).extend({
+        partnerId: zod_1.z.string().uuid().optional(),
+        marketingConsent: zod_1.z.boolean().default(false),
     });
     RegisterCommand.ResponseSchema = zod_1.z.object({
         data: zod_1.z.object({

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare namespace ResetPasswordCommand {
+    const RequestSchema: z.ZodObject<{
+        userId: z.ZodString;
+        restoreToken: z.ZodString;
+        newPassword: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        restoreToken: string;
+        newPassword: string;
+    }, {
+        userId: string;
+        restoreToken: string;
+        newPassword: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            accessToken: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            accessToken: string;
+        }, {
+            accessToken: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            accessToken: string;
+        };
+    }, {
+        data: {
+            accessToken: string;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=reset-password.command.d.ts.map

package/build/commands/auth/reset-password.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reset-password.command.d.ts","sourceRoot":"","sources":["../../../commands/auth/reset-password.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,yBAAiB,oBAAoB,CAAC;IAC3B,MAAM,aAAa;;;;;;;;;;;;MAIxB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/auth/reset-password.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResetPasswordCommand = void 0;
+const zod_1 = require("zod");
+var ResetPasswordCommand;
+(function (ResetPasswordCommand) {
+    ResetPasswordCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid(),
+        restoreToken: zod_1.z.string().min(6),
+        newPassword: zod_1.z.string().min(6).max(128),
+    });
+    ResetPasswordCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            accessToken: zod_1.z.string(),
+        }),
+    });
+})(ResetPasswordCommand || (exports.ResetPasswordCommand = ResetPasswordCommand = {}));

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare namespace RestorePasswordCommand {
+    const RequestSchema: z.ZodObject<Pick<{
+        uuid: z.ZodOptional<z.ZodString>;
+        siteId: z.ZodOptional<z.ZodString>;
+        email: z.ZodString;
+        password: z.ZodString;
+        role: z.ZodOptional<z.ZodNativeEnum<typeof import("../..").USER_ROLE>>;
+        status: z.ZodOptional<z.ZodNativeEnum<typeof import("../..").USER_STATUS>>;
+    }, "email">, "strip", z.ZodTypeAny, {
+        email: string;
+    }, {
+        email: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            message: string;
+        };
+    }, {
+        data: {
+            message: string;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=restore-password.command.d.ts.map

package/build/commands/auth/restore-password.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restore-password.command.d.ts","sourceRoot":"","sources":["../../../commands/auth/restore-password.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,sBAAsB,CAAC;IAC7B,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/commands/auth/restore-password.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestorePasswordCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var RestorePasswordCommand;
+(function (RestorePasswordCommand) {
+    RestorePasswordCommand.RequestSchema = models_1.UserSchema.pick({
+        email: true,
+    });
+    RestorePasswordCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            message: zod_1.z.string(),
+        }),
+    });
+})(RestorePasswordCommand || (exports.RestorePasswordCommand = RestorePasswordCommand = {}));

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare namespace VerifyEmailRetryCommand {
+    const RequestSchema: z.ZodObject<{
+        userId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+    }, {
+        userId: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            isSuccess: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            isSuccess: boolean;
+        }, {
+            isSuccess: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            isSuccess: boolean;
+        };
+    }, {
+        data: {
+            isSuccess: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=verify-email-retry.command.d.ts.map

package/build/commands/auth/verify-email-retry.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-email-retry.command.d.ts","sourceRoot":"","sources":["../../../commands/auth/verify-email-retry.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,yBAAiB,uBAAuB,CAAC;IAC9B,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/auth/verify-email-retry.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyEmailRetryCommand = void 0;
+const zod_1 = require("zod");
+var VerifyEmailRetryCommand;
+(function (VerifyEmailRetryCommand) {
+    VerifyEmailRetryCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid(),
+    });
+    VerifyEmailRetryCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(VerifyEmailRetryCommand || (exports.VerifyEmailRetryCommand = VerifyEmailRetryCommand = {}));

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare namespace VerifyEmailCommand {
+    const RequestSchema: z.ZodObject<{
+        verifyTokenHash: z.ZodString;
+        email: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        verifyTokenHash: string;
+    }, {
+        email: string;
+        verifyTokenHash: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            isSuccess: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            isSuccess: boolean;
+        }, {
+            isSuccess: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            isSuccess: boolean;
+        };
+    }, {
+        data: {
+            isSuccess: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=verify-email.command.d.ts.map

package/build/commands/auth/verify-email.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-email.command.d.ts","sourceRoot":"","sources":["../../../commands/auth/verify-email.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,aAAa;;;;;;;;;MAGxB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/auth/verify-email.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyEmailCommand = void 0;
+const zod_1 = require("zod");
+var VerifyEmailCommand;
+(function (VerifyEmailCommand) {
+    VerifyEmailCommand.RequestSchema = zod_1.z.object({
+        verifyTokenHash: zod_1.z.string().min(6),
+        email: zod_1.z.string().email(),
+    });
+    VerifyEmailCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(VerifyEmailCommand || (exports.VerifyEmailCommand = VerifyEmailCommand = {}));

package/build/commands/auth/vk-login.command.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare namespace VKLoginCommand {
+    const RequestSchema: z.ZodObject<{
+        code: z.ZodString;
+        code_verifier: z.ZodString;
+        device_id: z.ZodString;
+        state: z.ZodString;
+        marketingConsent: z.ZodDefault<z.ZodBoolean>;
+        partnerId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        marketingConsent: boolean;
+        code_verifier: string;
+        device_id: string;
+        state: string;
+        partnerId?: string | undefined;
+    }, {
+        code: string;
+        code_verifier: string;
+        device_id: string;
+        state: string;
+        partnerId?: string | undefined;
+        marketingConsent?: boolean | undefined;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            accessToken: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            accessToken: string;
+        }, {
+            accessToken: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            accessToken: string;
+        };
+    }, {
+        data: {
+            accessToken: string;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=vk-login.command.d.ts.map

package/build/commands/auth/vk-login.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vk-login.command.d.ts","sourceRoot":"","sources":["../../../commands/auth/vk-login.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,yBAAiB,cAAc,CAAC;IACrB,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;MAOxB,CAAC;IAEH,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/commands/auth/vk-login.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VKLoginCommand = void 0;
+const zod_1 = require("zod");
+var VKLoginCommand;
+(function (VKLoginCommand) {
+    VKLoginCommand.RequestSchema = zod_1.z.object({
+        code: zod_1.z.string(),
+        code_verifier: zod_1.z.string(),
+        device_id: zod_1.z.string(),
+        state: zod_1.z.string(),
+        marketingConsent: zod_1.z.boolean().default(false),
+        partnerId: zod_1.z.string().uuid().optional(),
+    });
+    VKLoginCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            accessToken: zod_1.z.string(),
+        }),
+    });
+})(VKLoginCommand || (exports.VKLoginCommand = VKLoginCommand = {}));

package/build/commands/auth/yandex-login.command.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare namespace YandexLoginCommand {
+    const RequestSchema: z.ZodObject<{
+        code: z.ZodString;
+        code_verifier: z.ZodString;
+        marketingConsent: z.ZodDefault<z.ZodBoolean>;
+        partnerId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        marketingConsent: boolean;
+        code_verifier: string;
+        partnerId?: string | undefined;
+    }, {
+        code: string;
+        code_verifier: string;
+        partnerId?: string | undefined;
+        marketingConsent?: boolean | undefined;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            accessToken: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            accessToken: string;
+        }, {
+            accessToken: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            accessToken: string;
+        };
+    }, {
+        data: {
+            accessToken: string;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=yandex-login.command.d.ts.map

package/build/commands/auth/yandex-login.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yandex-login.command.d.ts","sourceRoot":"","sources":["../../../commands/auth/yandex-login.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,aAAa;;;;;;;;;;;;;;;MAKxB,CAAC;IAEH,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/commands/auth/yandex-login.command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YandexLoginCommand = void 0;
+const zod_1 = require("zod");
+var YandexLoginCommand;
+(function (YandexLoginCommand) {
+    YandexLoginCommand.RequestSchema = zod_1.z.object({
+        code: zod_1.z.string(),
+        code_verifier: zod_1.z.string(),
+        marketingConsent: zod_1.z.boolean().default(false),
+        partnerId: zod_1.z.string().uuid().optional(),
+    });
+    YandexLoginCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            accessToken: zod_1.z.string(),
+        }),
+    });
+})(YandexLoginCommand || (exports.YandexLoginCommand = YandexLoginCommand = {}));

package/{commands/file/index.ts → build/commands/file/index.d.ts}

@@ -1 +1,2 @@
 export * from './upload-file.command';
+//# sourceMappingURL=index.d.ts.map

package/build/commands/file/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/file/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/build/commands/file/upload-file.command.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export declare namespace UploadFileCommand {
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            uuid: z.ZodString;
+            name: z.ZodString;
+            key: z.ZodString;
+            url: z.ZodString;
+            mimeType: z.ZodString;
+            size: z.ZodNumber;
+            type: z.ZodNativeEnum<typeof import("../..").FILE_TYPE>;
+            createdAt: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            type: import("../..").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            key: string;
+            createdAt?: string | Date | undefined;
+        }, {
+            uuid: string;
+            type: import("../..").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            key: string;
+            createdAt?: string | Date | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            uuid: string;
+            type: import("../..").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            key: string;
+            createdAt?: string | Date | undefined;
+        };
+    }, {
+        data: {
+            uuid: string;
+            type: import("../..").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            key: string;
+            createdAt?: string | Date | undefined;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=upload-file.command.d.ts.map

package/build/commands/file/upload-file.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-file.command.d.ts","sourceRoot":"","sources":["../../../commands/file/upload-file.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}