@aepstore-dev/contracts 1.41.0 → 1.42.0

package/dist/gen/activity.d.ts

@@ -0,0 +1,170 @@
+import { Observable } from "rxjs";
+export declare const protobufPackage = "activity.v1";
+/**
+ * Member names match the DB enum string values exactly (enums: String on the
+ * wire), so DB values pass straight through with no mapping. UNSPECIFIED=0
+ * represents "no value / not provided" (e.g. an optional list filter).
+ */
+export declare enum ReportType {
+    REPORT_TYPE_UNSPECIFIED = 0,
+    PRODUCT = 1,
+    PROFILE = 2,
+    REVIEW = 3,
+    UNRECOGNIZED = -1
+}
+export declare enum ReportStatus {
+    REPORT_STATUS_UNSPECIFIED = 0,
+    PENDING = 1,
+    IN_PROGRESS = 2,
+    RESOLVED = 3,
+    DISMISSED = 4,
+    UNRECOGNIZED = -1
+}
+export interface Report {
+    id: string;
+    type: ReportType;
+    objectId: string;
+    userId: string;
+    productId: string;
+    categories: ReportCategory[];
+    message: string;
+    status: ReportStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ReportResponse {
+    report: Report | undefined;
+}
+export interface CreateReportRequest {
+    userId: string;
+    type: ReportType;
+    objectId: string;
+    /** names */
+    categories: string[];
+    message: string;
+}
+export interface ListReportsRequest {
+    type: ReportType;
+    status: ReportStatus;
+    userId: string;
+    objectId: string;
+    page: number;
+    limit: number;
+}
+export interface ReportsListResponse {
+    items: Report[];
+    total: number;
+    page: number;
+    limit: number;
+}
+export interface ReportIdRequest {
+    id: string;
+}
+export interface ModerateReportRequest {
+    id: string;
+    /** 'accept' | 'reject' */
+    action: string;
+}
+export interface ReportCategory {
+    id: string;
+    name: string;
+    type: ReportType;
+    icon: string;
+    description: string;
+}
+export interface ReportCategoryResponse {
+    category: ReportCategory | undefined;
+}
+export interface CreateReportCategoryRequest {
+    name: string;
+    type: ReportType;
+    icon: string;
+    description: string;
+}
+export interface UpdateReportCategoryRequest {
+    id: string;
+    name: string;
+    icon: string;
+    description: string;
+}
+export interface ListReportCategoriesRequest {
+    type: ReportType;
+}
+export interface ReportCategoriesListResponse {
+    items: ReportCategory[];
+}
+export interface ReportCategoryIdRequest {
+    id: string;
+}
+export interface ReviewUser {
+    id: string;
+    username: string;
+    avatarUrl: string;
+}
+export interface Review {
+    id: string;
+    rating: number;
+    text: string;
+    productId: string;
+    createdAt: string;
+    updatedAt: string;
+    user: ReviewUser | undefined;
+}
+export interface ReviewResponse {
+    review: Review | undefined;
+}
+export interface CreateReviewRequest {
+    userId: string;
+    productId: string;
+    rating: number;
+    text: string;
+}
+export interface GetProductReviewsRequest {
+    productId: string;
+    page: number;
+    limit: number;
+}
+export interface ReviewsListResponse {
+    items: Review[];
+    total: number;
+    page: number;
+    limit: number;
+}
+export interface Ok {
+    ok: boolean;
+}
+export declare const ACTIVITY_V1_PACKAGE_NAME = "activity.v1";
+export interface ActivityServiceClient {
+    /** Reports */
+    reportCreate(request: CreateReportRequest): Observable<ReportResponse>;
+    reportList(request: ListReportsRequest): Observable<ReportsListResponse>;
+    reportGet(request: ReportIdRequest): Observable<ReportResponse>;
+    reportModerate(request: ModerateReportRequest): Observable<ReportResponse>;
+    /** Report categories */
+    reportCategoryCreate(request: CreateReportCategoryRequest): Observable<ReportCategoryResponse>;
+    reportCategoryList(request: ListReportCategoriesRequest): Observable<ReportCategoriesListResponse>;
+    reportCategoryGet(request: ReportCategoryIdRequest): Observable<ReportCategoryResponse>;
+    reportCategoryUpdate(request: UpdateReportCategoryRequest): Observable<ReportCategoryResponse>;
+    reportCategoryDelete(request: ReportCategoryIdRequest): Observable<Ok>;
+    /** Reviews */
+    reviewCreate(request: CreateReviewRequest): Observable<ReviewResponse>;
+    getProductReviews(request: GetProductReviewsRequest): Observable<ReviewsListResponse>;
+}
+export interface ActivityServiceController {
+    /** Reports */
+    reportCreate(request: CreateReportRequest): Promise<ReportResponse> | Observable<ReportResponse> | ReportResponse;
+    reportList(request: ListReportsRequest): Promise<ReportsListResponse> | Observable<ReportsListResponse> | ReportsListResponse;
+    reportGet(request: ReportIdRequest): Promise<ReportResponse> | Observable<ReportResponse> | ReportResponse;
+    reportModerate(request: ModerateReportRequest): Promise<ReportResponse> | Observable<ReportResponse> | ReportResponse;
+    /** Report categories */
+    reportCategoryCreate(request: CreateReportCategoryRequest): Promise<ReportCategoryResponse> | Observable<ReportCategoryResponse> | ReportCategoryResponse;
+    reportCategoryList(request: ListReportCategoriesRequest): Promise<ReportCategoriesListResponse> | Observable<ReportCategoriesListResponse> | ReportCategoriesListResponse;
+    reportCategoryGet(request: ReportCategoryIdRequest): Promise<ReportCategoryResponse> | Observable<ReportCategoryResponse> | ReportCategoryResponse;
+    reportCategoryUpdate(request: UpdateReportCategoryRequest): Promise<ReportCategoryResponse> | Observable<ReportCategoryResponse> | ReportCategoryResponse;
+    reportCategoryDelete(request: ReportCategoryIdRequest): Promise<Ok> | Observable<Ok> | Ok;
+    /** Reviews */
+    reviewCreate(request: CreateReviewRequest): Promise<ReviewResponse> | Observable<ReviewResponse> | ReviewResponse;
+    getProductReviews(request: GetProductReviewsRequest): Promise<ReviewsListResponse> | Observable<ReviewsListResponse> | ReviewsListResponse;
+}
+export declare function ActivityServiceControllerMethods(): (constructor: Function) => void;
+export declare const ACTIVITY_SERVICE_NAME = "ActivityService";

package/dist/gen/activity.js

@@ -0,0 +1,62 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v7.35.0
+// source: activity.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIVITY_SERVICE_NAME = exports.ACTIVITY_V1_PACKAGE_NAME = exports.ReportStatus = exports.ReportType = exports.protobufPackage = void 0;
+exports.ActivityServiceControllerMethods = ActivityServiceControllerMethods;
+/* eslint-disable */
+const microservices_1 = require("@nestjs/microservices");
+exports.protobufPackage = "activity.v1";
+/**
+ * Member names match the DB enum string values exactly (enums: String on the
+ * wire), so DB values pass straight through with no mapping. UNSPECIFIED=0
+ * represents "no value / not provided" (e.g. an optional list filter).
+ */
+var ReportType;
+(function (ReportType) {
+    ReportType[ReportType["REPORT_TYPE_UNSPECIFIED"] = 0] = "REPORT_TYPE_UNSPECIFIED";
+    ReportType[ReportType["PRODUCT"] = 1] = "PRODUCT";
+    ReportType[ReportType["PROFILE"] = 2] = "PROFILE";
+    ReportType[ReportType["REVIEW"] = 3] = "REVIEW";
+    ReportType[ReportType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ReportType || (exports.ReportType = ReportType = {}));
+var ReportStatus;
+(function (ReportStatus) {
+    ReportStatus[ReportStatus["REPORT_STATUS_UNSPECIFIED"] = 0] = "REPORT_STATUS_UNSPECIFIED";
+    ReportStatus[ReportStatus["PENDING"] = 1] = "PENDING";
+    ReportStatus[ReportStatus["IN_PROGRESS"] = 2] = "IN_PROGRESS";
+    ReportStatus[ReportStatus["RESOLVED"] = 3] = "RESOLVED";
+    ReportStatus[ReportStatus["DISMISSED"] = 4] = "DISMISSED";
+    ReportStatus[ReportStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ReportStatus || (exports.ReportStatus = ReportStatus = {}));
+exports.ACTIVITY_V1_PACKAGE_NAME = "activity.v1";
+function ActivityServiceControllerMethods() {
+    return function (constructor) {
+        const grpcMethods = [
+            "reportCreate",
+            "reportList",
+            "reportGet",
+            "reportModerate",
+            "reportCategoryCreate",
+            "reportCategoryList",
+            "reportCategoryGet",
+            "reportCategoryUpdate",
+            "reportCategoryDelete",
+            "reviewCreate",
+            "getProductReviews",
+        ];
+        for (const method of grpcMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcMethod)("ActivityService", method)(constructor.prototype[method], method, descriptor);
+        }
+        const grpcStreamMethods = [];
+        for (const method of grpcStreamMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcStreamMethod)("ActivityService", method)(constructor.prototype[method], method, descriptor);
+        }
+    };
+}
+exports.ACTIVITY_SERVICE_NAME = "ActivityService";

package/dist/gen/auth.d.ts

@@ -0,0 +1,220 @@
+import { Observable } from "rxjs";
+export declare const protobufPackage = "auth.v1";
+export declare enum TwoFactorType {
+    NONE = 0,
+    APP = 1,
+    EMAIL = 2,
+    UNRECOGNIZED = -1
+}
+/** Login by username OR email (one of the two must be set). */
+export interface LoginRequest {
+    password: string;
+    /** username OR email — resolved by the service */
+    credentials: string;
+    /**
+     * Gateway-supplied audit context. LoginEvent rows for LOGIN /
+     * PASSWORD_FAIL get the same ip/user-agent that REFRESH and RESTORE
+     * already carry; the gRPC layer has no transport-level access to
+     * either, so the gateway extracts them from the HTTP request.
+     */
+    userAgent: string;
+    ip: string;
+}
+export interface RegisterRequest {
+    email: string;
+    username: string;
+    password: string;
+    /** optional, attached by gateway from req */
+    ip: string;
+}
+/** type ∈ { twofa, reset, totp_generate, totp_activate, confirm } (legacy strings) */
+export interface CreateCodeRequest {
+    email: string;
+    type: string;
+}
+/**
+ * type ∈ { twofa, twofa_deactivate, reset, totp, totp_deactivate, backup, confirm }
+ * new_password is only used by the 'reset' flow.
+ */
+export interface VerifyCodeRequest {
+    email: string;
+    code: string;
+    type: string;
+    /** optional */
+    newPassword: string;
+}
+export interface CheckTokenRequest {
+    token: string;
+}
+export interface RefreshTokenRequest {
+    refreshToken: string;
+    /** optional */
+    userAgent: string;
+    /** optional */
+    ip: string;
+}
+export interface Get2faStatusRequest {
+    username: string;
+}
+export interface GetProfileRequest {
+    userId: string;
+}
+export interface AuthUser {
+    id: string;
+    username: string;
+    email: string;
+    avatarUrl: string;
+    bannerUrl: string;
+    roles: string[];
+    /** primary role (roles[0]) */
+    role: string;
+    isVerified: boolean;
+    twoFactorType: TwoFactorType;
+    twoFactorEnabled: boolean;
+    /** Decimal as string (D7) */
+    balance: string;
+}
+/**
+ * Unified result for login/register/createCode/verifyCode/refresh. Which fields
+ * are populated depends on the flow:
+ *   - fully authenticated → access_token + refresh_token + expires_in + user
+ *   - 2FA required / pending confirm → message + requires_2fa + two_factor_type + user (no tokens)
+ *   - totp_generate → secret + otpauth + qr (+ user)
+ *   - totp_activate → backup_codes (+ tokens/user)
+ */
+export interface AuthResult {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    user: AuthUser | undefined;
+    message: string;
+    requires2fa: boolean;
+    twoFactorType: TwoFactorType;
+    /** TOTP setup extras */
+    secret: string;
+    otpauth: string;
+    /** data URL (PNG) */
+    qr: string;
+    backupCodes: string[];
+}
+export interface TwoFactorStatusResponse {
+    twoFactorType: TwoFactorType;
+    has2fa: boolean;
+    isVerified: boolean;
+}
+export interface Empty {
+}
+export interface LogoutCurrentRequest {
+    refreshToken: string;
+}
+export interface LogoutAllRequest {
+    userId: string;
+}
+export interface LogoutResponse {
+    ok: boolean;
+    /** number of refresh-token rows deleted */
+    removed: number;
+}
+export interface RestoreLoginRequest {
+    /** email or username */
+    credentials: string;
+    password: string;
+    userAgent: string;
+    ip: string;
+}
+export interface ListLoginHistoryRequest {
+    userId: string;
+    page: number;
+    limit: number;
+}
+export interface LoginEventRow {
+    id: string;
+    /** LOGIN | LOGOUT | REFRESH | TWO_FA_FAIL | PASSWORD_FAIL | BLOCKED | RESTORE */
+    type: string;
+    success: boolean;
+    reason: string;
+    ip: string;
+    userAgent: string;
+    createdAt: string;
+}
+export interface ListLoginHistoryResponse {
+    items: LoginEventRow[];
+    total: number;
+    page: number;
+    limit: number;
+}
+export declare const AUTH_V1_PACKAGE_NAME = "auth.v1";
+/**
+ * Ported from legacy auth-service (@MessagePattern → @GrpcMethod).
+ * Tokens are HMAC primitives from @aepstore-dev/passport:
+ *   - access token: short TTL, carries userId; the gateway validates it
+ *     locally via PassportAuthGuard (no round-trip here).
+ *   - refresh token: long TTL HMAC + a RefreshToken DB row (device list +
+ *     revocation). Refresh verifies the HMAC AND that the row still exists.
+ */
+export interface AuthServiceClient {
+    login(request: LoginRequest): Observable<AuthResult>;
+    register(request: RegisterRequest): Observable<AuthResult>;
+    createCode(request: CreateCodeRequest): Observable<AuthResult>;
+    verifyCode(request: VerifyCodeRequest): Observable<AuthResult>;
+    checkToken(request: CheckTokenRequest): Observable<AuthUser>;
+    refreshToken(request: RefreshTokenRequest): Observable<AuthResult>;
+    get2FaStatus(request: Get2faStatusRequest): Observable<TwoFactorStatusResponse>;
+    getProfile(request: GetProfileRequest): Observable<AuthUser>;
+    cleanupExpiredTotpSetups(request: Empty): Observable<Empty>;
+    /**
+     * Logout — kill refresh tokens. LogoutCurrent kills only the one whose
+     * HMAC matches; LogoutAll wipes every row for the user.
+     */
+    logoutCurrent(request: LogoutCurrentRequest): Observable<LogoutResponse>;
+    logoutAll(request: LogoutAllRequest): Observable<LogoutResponse>;
+    /**
+     * Self-service restore. Verifies credentials + password against a
+     * soft-deleted user, clears deletedAt/scheduledForHardDelete, and issues
+     * fresh tokens — the one auth path that DOES read deletedAt accounts.
+     */
+    restoreLogin(request: RestoreLoginRequest): Observable<AuthResult>;
+    /**
+     * Login history. Read-only audit feed for the settings page; rows come
+     * from LoginEvent. Internal alternative: tasks-service GC.
+     */
+    listLoginHistory(request: ListLoginHistoryRequest): Observable<ListLoginHistoryResponse>;
+}
+/**
+ * Ported from legacy auth-service (@MessagePattern → @GrpcMethod).
+ * Tokens are HMAC primitives from @aepstore-dev/passport:
+ *   - access token: short TTL, carries userId; the gateway validates it
+ *     locally via PassportAuthGuard (no round-trip here).
+ *   - refresh token: long TTL HMAC + a RefreshToken DB row (device list +
+ *     revocation). Refresh verifies the HMAC AND that the row still exists.
+ */
+export interface AuthServiceController {
+    login(request: LoginRequest): Promise<AuthResult> | Observable<AuthResult> | AuthResult;
+    register(request: RegisterRequest): Promise<AuthResult> | Observable<AuthResult> | AuthResult;
+    createCode(request: CreateCodeRequest): Promise<AuthResult> | Observable<AuthResult> | AuthResult;
+    verifyCode(request: VerifyCodeRequest): Promise<AuthResult> | Observable<AuthResult> | AuthResult;
+    checkToken(request: CheckTokenRequest): Promise<AuthUser> | Observable<AuthUser> | AuthUser;
+    refreshToken(request: RefreshTokenRequest): Promise<AuthResult> | Observable<AuthResult> | AuthResult;
+    get2FaStatus(request: Get2faStatusRequest): Promise<TwoFactorStatusResponse> | Observable<TwoFactorStatusResponse> | TwoFactorStatusResponse;
+    getProfile(request: GetProfileRequest): Promise<AuthUser> | Observable<AuthUser> | AuthUser;
+    cleanupExpiredTotpSetups(request: Empty): Promise<Empty> | Observable<Empty> | Empty;
+    /**
+     * Logout — kill refresh tokens. LogoutCurrent kills only the one whose
+     * HMAC matches; LogoutAll wipes every row for the user.
+     */
+    logoutCurrent(request: LogoutCurrentRequest): Promise<LogoutResponse> | Observable<LogoutResponse> | LogoutResponse;
+    logoutAll(request: LogoutAllRequest): Promise<LogoutResponse> | Observable<LogoutResponse> | LogoutResponse;
+    /**
+     * Self-service restore. Verifies credentials + password against a
+     * soft-deleted user, clears deletedAt/scheduledForHardDelete, and issues
+     * fresh tokens — the one auth path that DOES read deletedAt accounts.
+     */
+    restoreLogin(request: RestoreLoginRequest): Promise<AuthResult> | Observable<AuthResult> | AuthResult;
+    /**
+     * Login history. Read-only audit feed for the settings page; rows come
+     * from LoginEvent. Internal alternative: tasks-service GC.
+     */
+    listLoginHistory(request: ListLoginHistoryRequest): Promise<ListLoginHistoryResponse> | Observable<ListLoginHistoryResponse> | ListLoginHistoryResponse;
+}
+export declare function AuthServiceControllerMethods(): (constructor: Function) => void;
+export declare const AUTH_SERVICE_NAME = "AuthService";

package/dist/gen/auth.js

@@ -0,0 +1,49 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v7.35.0
+// source: auth.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTH_SERVICE_NAME = exports.AUTH_V1_PACKAGE_NAME = exports.TwoFactorType = exports.protobufPackage = void 0;
+exports.AuthServiceControllerMethods = AuthServiceControllerMethods;
+/* eslint-disable */
+const microservices_1 = require("@nestjs/microservices");
+exports.protobufPackage = "auth.v1";
+var TwoFactorType;
+(function (TwoFactorType) {
+    TwoFactorType[TwoFactorType["NONE"] = 0] = "NONE";
+    TwoFactorType[TwoFactorType["APP"] = 1] = "APP";
+    TwoFactorType[TwoFactorType["EMAIL"] = 2] = "EMAIL";
+    TwoFactorType[TwoFactorType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(TwoFactorType || (exports.TwoFactorType = TwoFactorType = {}));
+exports.AUTH_V1_PACKAGE_NAME = "auth.v1";
+function AuthServiceControllerMethods() {
+    return function (constructor) {
+        const grpcMethods = [
+            "login",
+            "register",
+            "createCode",
+            "verifyCode",
+            "checkToken",
+            "refreshToken",
+            "get2FaStatus",
+            "getProfile",
+            "cleanupExpiredTotpSetups",
+            "logoutCurrent",
+            "logoutAll",
+            "restoreLogin",
+            "listLoginHistory",
+        ];
+        for (const method of grpcMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcMethod)("AuthService", method)(constructor.prototype[method], method, descriptor);
+        }
+        const grpcStreamMethods = [];
+        for (const method of grpcStreamMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcStreamMethod)("AuthService", method)(constructor.prototype[method], method, descriptor);
+        }
+    };
+}
+exports.AUTH_SERVICE_NAME = "AuthService";

package/dist/gen/mail.d.ts

@@ -0,0 +1,70 @@
+import { Observable } from "rxjs";
+export declare const protobufPackage = "mail.v1";
+export interface MailAck {
+    queued: boolean;
+}
+export interface SendRegRequest {
+    userId: string;
+    email: string;
+    username: string;
+    fullName: string;
+}
+export interface Send2faRequest {
+    email: string;
+    code: string;
+    username: string;
+}
+export interface SendPasswordResetRequest {
+    email: string;
+    code: string;
+    username: string;
+}
+export interface SendRegistrationConfirmRequest {
+    email: string;
+    code: string;
+    username: string;
+}
+export interface SendDataExportReadyRequest {
+    email: string;
+    username: string;
+    /** signed S3 URL */
+    fileUrl: string;
+    /** for the message body */
+    urlTtlHours: number;
+    fileSize: number;
+}
+export declare const MAIL_V1_PACKAGE_NAME = "mail.v1";
+/**
+ * Legacy mail-service used @EventPattern (fire-and-forget). In the new gRPC
+ * stack each becomes a unary RPC that returns an Ack. Callers ignore the
+ * response if they don't care about delivery.
+ */
+export interface MailServiceClient {
+    sendReg(request: SendRegRequest): Observable<MailAck>;
+    send2Fa(request: Send2faRequest): Observable<MailAck>;
+    sendPasswordReset(request: SendPasswordResetRequest): Observable<MailAck>;
+    sendRegistrationConfirm(request: SendRegistrationConfirmRequest): Observable<MailAck>;
+    /**
+     * GDPR data-export delivery — tasks-service fires after the JSON dump
+     * lands in S3; mail-service sends the signed URL with a sensible TTL note.
+     */
+    sendDataExportReady(request: SendDataExportReadyRequest): Observable<MailAck>;
+}
+/**
+ * Legacy mail-service used @EventPattern (fire-and-forget). In the new gRPC
+ * stack each becomes a unary RPC that returns an Ack. Callers ignore the
+ * response if they don't care about delivery.
+ */
+export interface MailServiceController {
+    sendReg(request: SendRegRequest): Promise<MailAck> | Observable<MailAck> | MailAck;
+    send2Fa(request: Send2faRequest): Promise<MailAck> | Observable<MailAck> | MailAck;
+    sendPasswordReset(request: SendPasswordResetRequest): Promise<MailAck> | Observable<MailAck> | MailAck;
+    sendRegistrationConfirm(request: SendRegistrationConfirmRequest): Promise<MailAck> | Observable<MailAck> | MailAck;
+    /**
+     * GDPR data-export delivery — tasks-service fires after the JSON dump
+     * lands in S3; mail-service sends the signed URL with a sensible TTL note.
+     */
+    sendDataExportReady(request: SendDataExportReadyRequest): Promise<MailAck> | Observable<MailAck> | MailAck;
+}
+export declare function MailServiceControllerMethods(): (constructor: Function) => void;
+export declare const MAIL_SERVICE_NAME = "MailService";

package/dist/gen/mail.js

@@ -0,0 +1,34 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v7.35.0
+// source: mail.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAIL_SERVICE_NAME = exports.MAIL_V1_PACKAGE_NAME = exports.protobufPackage = void 0;
+exports.MailServiceControllerMethods = MailServiceControllerMethods;
+/* eslint-disable */
+const microservices_1 = require("@nestjs/microservices");
+exports.protobufPackage = "mail.v1";
+exports.MAIL_V1_PACKAGE_NAME = "mail.v1";
+function MailServiceControllerMethods() {
+    return function (constructor) {
+        const grpcMethods = [
+            "sendReg",
+            "send2Fa",
+            "sendPasswordReset",
+            "sendRegistrationConfirm",
+            "sendDataExportReady",
+        ];
+        for (const method of grpcMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcMethod)("MailService", method)(constructor.prototype[method], method, descriptor);
+        }
+        const grpcStreamMethods = [];
+        for (const method of grpcStreamMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcStreamMethod)("MailService", method)(constructor.prototype[method], method, descriptor);
+        }
+    };
+}
+exports.MAIL_SERVICE_NAME = "MailService";