@86d-app/reviews 0.0.4 → 0.0.13

package/dist/admin/endpoints/index.d.ts

@@ -0,0 +1,167 @@
+export declare const adminEndpoints: {
+    "/admin/reviews": import("better-call").StrictEndpoint<"/admin/reviews", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                pending: "pending";
+                approved: "approved";
+                rejected: "rejected";
+            }>>;
+            productId: import("zod").ZodOptional<import("zod").ZodString>;
+            take: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            skip: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        reviews: import("../..").Review[];
+        total: number;
+    }>;
+    "/admin/reviews/analytics": import("better-call").StrictEndpoint<"/admin/reviews/analytics", {
+        method: "GET";
+    }, {
+        analytics: import("../..").ReviewAnalytics;
+    }>;
+    "/admin/reviews/reports": import("better-call").StrictEndpoint<"/admin/reviews/reports", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                pending: "pending";
+                resolved: "resolved";
+                dismissed: "dismissed";
+            }>>;
+            reviewId: import("zod").ZodOptional<import("zod").ZodString>;
+            take: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            skip: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        reports: import("../..").ReviewReport[];
+    }>;
+    "/admin/reviews/reports/:id/update": import("better-call").StrictEndpoint<"/admin/reviews/reports/:id/update", {
+        method: "PUT";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: import("zod").ZodObject<{
+            status: import("zod").ZodEnum<{
+                resolved: "resolved";
+                dismissed: "dismissed";
+            }>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        report?: never;
+    } | {
+        report: import("../..").ReviewReport;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/reviews/requests": import("better-call").StrictEndpoint<"/admin/reviews/requests", {
+        method: "GET";
+        query: import("zod").ZodOptional<import("zod").ZodObject<{
+            take: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            skip: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        }, import("zod/v4/core").$strip>>;
+    }, {
+        requests: import("../..").ReviewRequest[];
+    }>;
+    "/admin/reviews/request-stats": import("better-call").StrictEndpoint<"/admin/reviews/request-stats", {
+        method: "GET";
+    }, {
+        stats: import("../..").ReviewRequestStats;
+    }>;
+    "/admin/reviews/send-request": import("better-call").StrictEndpoint<"/admin/reviews/send-request", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            orderId: import("zod").ZodString;
+            orderNumber: import("zod").ZodString;
+            email: import("zod").ZodString;
+            customerName: import("zod").ZodString;
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                productId: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        request?: never;
+    } | {
+        request: import("../..").ReviewRequest;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/reviews/:id": import("better-call").StrictEndpoint<"/admin/reviews/:id", {
+        method: "GET";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        review?: never;
+    } | {
+        review: import("../..").Review;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/reviews/:id/approve": import("better-call").StrictEndpoint<"/admin/reviews/:id/approve", {
+        method: "PUT";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        review?: never;
+    } | {
+        review: import("../..").Review;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/reviews/:id/reject": import("better-call").StrictEndpoint<"/admin/reviews/:id/reject", {
+        method: "PUT";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        review?: never;
+    } | {
+        review: import("../..").Review;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/reviews/:id/respond": import("better-call").StrictEndpoint<"/admin/reviews/:id/respond", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: import("zod").ZodObject<{
+            response: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        review?: never;
+    } | {
+        review: import("../..").Review;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/reviews/:id/delete": import("better-call").StrictEndpoint<"/admin/reviews/:id/delete", {
+        method: "DELETE";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        deleted?: never;
+    } | {
+        deleted: boolean;
+        error?: never;
+        status?: never;
+    }>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/admin/endpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAa1B,CAAC"}

package/dist/admin/endpoints/list-reports.d.ts

@@ -0,0 +1,17 @@
+import { z } from "@86d-app/core";
+export declare const listReports: import("better-call").StrictEndpoint<"/admin/reviews/reports", {
+    method: "GET";
+    query: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            resolved: "resolved";
+            dismissed: "dismissed";
+        }>>;
+        reviewId: z.ZodOptional<z.ZodString>;
+        take: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        skip: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+}, {
+    reports: import("../..").ReviewReport[];
+}>;
+//# sourceMappingURL=list-reports.d.ts.map

package/dist/admin/endpoints/list-reports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-reports.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/list-reports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;EAqBvB,CAAC"}

package/dist/admin/endpoints/list-review-requests.d.ts

@@ -0,0 +1,11 @@
+import { z } from "@86d-app/core";
+export declare const listReviewRequests: import("better-call").StrictEndpoint<"/admin/reviews/requests", {
+    method: "GET";
+    query: z.ZodOptional<z.ZodObject<{
+        take: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        skip: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+}, {
+    requests: import("../..").ReviewRequest[];
+}>;
+//# sourceMappingURL=list-review-requests.d.ts.map

package/dist/admin/endpoints/list-review-requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-review-requests.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/list-review-requests.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,kBAAkB;;;;;;;;EAmB9B,CAAC"}

package/dist/admin/endpoints/list-reviews.d.ts

@@ -0,0 +1,18 @@
+import { z } from "@86d-app/core";
+export declare const listReviews: import("better-call").StrictEndpoint<"/admin/reviews", {
+    method: "GET";
+    query: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            approved: "approved";
+            rejected: "rejected";
+        }>>;
+        productId: z.ZodOptional<z.ZodString>;
+        take: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        skip: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+}, {
+    reviews: import("../..").Review[];
+    total: number;
+}>;
+//# sourceMappingURL=list-reviews.d.ts.map

package/dist/admin/endpoints/list-reviews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-reviews.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/list-reviews.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;EAqBvB,CAAC"}

package/dist/admin/endpoints/reject-review.d.ts

@@ -0,0 +1,16 @@
+import { z } from "@86d-app/core";
+export declare const rejectReview: import("better-call").StrictEndpoint<"/admin/reviews/:id/reject", {
+    method: "PUT";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    review?: never;
+} | {
+    review: import("../..").Review;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=reject-review.d.ts.map

package/dist/admin/endpoints/reject-review.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject-review.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/reject-review.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,YAAY;;;;;;;;;;;;;EAexB,CAAC"}

package/dist/admin/endpoints/respond-review.d.ts

@@ -0,0 +1,19 @@
+import { z } from "@86d-app/core";
+export declare const respondReview: import("better-call").StrictEndpoint<"/admin/reviews/:id/respond", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    body: z.ZodObject<{
+        response: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    review?: never;
+} | {
+    review: import("../..").Review;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=respond-review.d.ts.map

package/dist/admin/endpoints/respond-review.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"respond-review.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/respond-review.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,CAAC,EAAE,MAAM,eAAe,CAAC;AAGrE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;EAkBzB,CAAC"}

package/dist/admin/endpoints/review-analytics.d.ts

@@ -0,0 +1,6 @@
+export declare const reviewAnalytics: import("better-call").StrictEndpoint<"/admin/reviews/analytics", {
+    method: "GET";
+}, {
+    analytics: import("../..").ReviewAnalytics;
+}>;
+//# sourceMappingURL=review-analytics.d.ts.map

package/dist/admin/endpoints/review-analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-analytics.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/review-analytics.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;;;EAU3B,CAAC"}

package/dist/admin/endpoints/review-request-stats.d.ts

@@ -0,0 +1,6 @@
+export declare const reviewRequestStats: import("better-call").StrictEndpoint<"/admin/reviews/request-stats", {
+    method: "GET";
+}, {
+    stats: import("../..").ReviewRequestStats;
+}>;
+//# sourceMappingURL=review-request-stats.d.ts.map

package/dist/admin/endpoints/review-request-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-request-stats.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/review-request-stats.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB;;;;EAQ9B,CAAC"}

package/dist/admin/endpoints/send-review-request.d.ts

@@ -0,0 +1,23 @@
+import { z } from "@86d-app/core";
+export declare const sendReviewRequest: import("better-call").StrictEndpoint<"/admin/reviews/send-request", {
+    method: "POST";
+    body: z.ZodObject<{
+        orderId: z.ZodString;
+        orderNumber: z.ZodString;
+        email: z.ZodString;
+        customerName: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            productId: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    request?: never;
+} | {
+    request: import("../..").ReviewRequest;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=send-review-request.d.ts.map

package/dist/admin/endpoints/send-review-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-review-request.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/send-review-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;EAqC7B,CAAC"}

package/dist/admin/endpoints/update-report.d.ts

@@ -0,0 +1,22 @@
+import { z } from "@86d-app/core";
+export declare const updateReport: import("better-call").StrictEndpoint<"/admin/reviews/reports/:id/update", {
+    method: "PUT";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    body: z.ZodObject<{
+        status: z.ZodEnum<{
+            resolved: "resolved";
+            dismissed: "dismissed";
+        }>;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    report?: never;
+} | {
+    report: import("../..").ReviewReport;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=update-report.d.ts.map

package/dist/admin/endpoints/update-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-report.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/update-report.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;EAkBxB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { Module, ModuleConfig } from "@86d-app/core";
+export type { RatingSummary, ReportStatus, Review, ReviewAnalytics, ReviewController, ReviewImage, ReviewReport, ReviewRequest, ReviewRequestStats, ReviewSortBy, ReviewStatus, ReviewVote, } from "./service";
+export interface ReviewsOptions extends ModuleConfig {
+    /** Auto-approve reviews (no moderation queue) */
+    autoApprove?: string;
+}
+export default function reviews(options?: ReviewsOptions): Module;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAiB,MAAM,eAAe,CAAC;AAMzE,YAAY,EACX,aAAa,EACb,YAAY,EACZ,MAAM,EACN,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,UAAU,GACV,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAe,SAAQ,YAAY;IACnD,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAoDhE"}

package/dist/schema.d.ts

@@ -0,0 +1,136 @@
+export declare const reviewsSchema: {
+    review: {
+        fields: {
+            id: {
+                type: "string";
+                required: true;
+            };
+            productId: {
+                type: "string";
+                required: true;
+            };
+            customerId: {
+                type: "string";
+                required: false;
+            };
+            authorName: {
+                type: "string";
+                required: true;
+            };
+            authorEmail: {
+                type: "string";
+                required: true;
+            };
+            rating: {
+                type: "number";
+                required: true;
+            };
+            title: {
+                type: "string";
+                required: false;
+            };
+            body: {
+                type: "string";
+                required: true;
+            };
+            status: {
+                type: "string";
+                required: true;
+                defaultValue: string;
+            };
+            isVerifiedPurchase: {
+                type: "boolean";
+                required: true;
+                defaultValue: false;
+            };
+            helpfulCount: {
+                type: "number";
+                required: true;
+                defaultValue: number;
+            };
+            images: {
+                type: "json";
+                required: false;
+            };
+            merchantResponse: {
+                type: "string";
+                required: false;
+            };
+            merchantResponseAt: {
+                type: "date";
+                required: false;
+            };
+            moderationNote: {
+                type: "string";
+                required: false;
+            };
+            createdAt: {
+                type: "date";
+                required: true;
+                defaultValue: () => Date;
+            };
+            updatedAt: {
+                type: "date";
+                required: true;
+                defaultValue: () => Date;
+                onUpdate: () => Date;
+            };
+        };
+    };
+    reviewVote: {
+        fields: {
+            id: {
+                type: "string";
+                required: true;
+            };
+            reviewId: {
+                type: "string";
+                required: true;
+            };
+            voterId: {
+                type: "string";
+                required: true;
+            };
+            createdAt: {
+                type: "date";
+                required: true;
+                defaultValue: () => Date;
+            };
+        };
+    };
+    reviewReport: {
+        fields: {
+            id: {
+                type: "string";
+                required: true;
+            };
+            reviewId: {
+                type: "string";
+                required: true;
+            };
+            reporterId: {
+                type: "string";
+                required: false;
+            };
+            reason: {
+                type: "string";
+                required: true;
+            };
+            details: {
+                type: "string";
+                required: false;
+            };
+            status: {
+                type: "string";
+                required: true;
+                defaultValue: string;
+            };
+            createdAt: {
+                type: "date";
+                required: true;
+                defaultValue: () => Date;
+            };
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DF,CAAC"}

package/dist/service-impl.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleDataService } from "@86d-app/core";
+import type { ReviewController } from "./service";
+export declare function createReviewController(data: ModuleDataService, options?: {
+    autoApprove?: boolean;
+}): ReviewController;
+//# sourceMappingURL=service-impl.d.ts.map

package/dist/service-impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-impl.d.ts","sourceRoot":"","sources":["../src/service-impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAEX,gBAAgB,EAMhB,MAAM,WAAW,CAAC;AAwBnB,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GACjC,gBAAgB,CAsXlB"}

package/dist/service.d.ts

@@ -0,0 +1,149 @@
+import type { ModuleController } from "@86d-app/core";
+export type ReviewStatus = "pending" | "approved" | "rejected";
+export type ReportStatus = "pending" | "resolved" | "dismissed";
+export type ReviewSortBy = "recent" | "oldest" | "highest" | "lowest" | "helpful";
+export interface ReviewImage {
+    url: string;
+    caption?: string | undefined;
+}
+export interface Review {
+    id: string;
+    productId: string;
+    customerId?: string | undefined;
+    authorName: string;
+    authorEmail: string;
+    rating: number;
+    title?: string | undefined;
+    body: string;
+    status: ReviewStatus;
+    isVerifiedPurchase: boolean;
+    helpfulCount: number;
+    images?: ReviewImage[] | undefined;
+    merchantResponse?: string | undefined;
+    merchantResponseAt?: Date | undefined;
+    moderationNote?: string | undefined;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface RatingSummary {
+    average: number;
+    count: number;
+    distribution: Record<string, number>;
+}
+export interface ReviewVote {
+    id: string;
+    reviewId: string;
+    voterId: string;
+    createdAt: Date;
+}
+export interface ReviewReport {
+    id: string;
+    reviewId: string;
+    reporterId?: string | undefined;
+    reason: string;
+    details?: string | undefined;
+    status: ReportStatus;
+    createdAt: Date;
+}
+export interface ReviewController extends ModuleController {
+    createReview(params: {
+        productId: string;
+        authorName: string;
+        authorEmail: string;
+        rating: number;
+        title?: string | undefined;
+        body: string;
+        customerId?: string | undefined;
+        isVerifiedPurchase?: boolean | undefined;
+        images?: ReviewImage[] | undefined;
+    }): Promise<Review>;
+    getReview(id: string): Promise<Review | null>;
+    listReviewsByProduct(productId: string, params?: {
+        approvedOnly?: boolean | undefined;
+        take?: number | undefined;
+        skip?: number | undefined;
+        sortBy?: ReviewSortBy | undefined;
+    }): Promise<Review[]>;
+    listReviews(params?: {
+        productId?: string | undefined;
+        status?: ReviewStatus | undefined;
+        take?: number | undefined;
+        skip?: number | undefined;
+    }): Promise<Review[]>;
+    updateReviewStatus(id: string, status: ReviewStatus, moderationNote?: string | undefined): Promise<Review | null>;
+    deleteReview(id: string): Promise<boolean>;
+    getProductRatingSummary(productId: string): Promise<RatingSummary>;
+    addMerchantResponse(id: string, response: string): Promise<Review | null>;
+    markHelpful(id: string): Promise<Review | null>;
+    voteHelpful(reviewId: string, voterId: string): Promise<{
+        review: Review;
+        alreadyVoted: boolean;
+    } | null>;
+    getReviewAnalytics(): Promise<ReviewAnalytics>;
+    createReviewRequest(params: {
+        orderId: string;
+        orderNumber: string;
+        email: string;
+        customerName: string;
+        items: Array<{
+            productId: string;
+            name: string;
+        }>;
+    }): Promise<ReviewRequest>;
+    getReviewRequest(orderId: string): Promise<ReviewRequest | null>;
+    listReviewRequests(params?: {
+        take?: number | undefined;
+        skip?: number | undefined;
+    }): Promise<ReviewRequest[]>;
+    getReviewRequestStats(): Promise<ReviewRequestStats>;
+    listReviewsByCustomer(customerId: string, params?: {
+        status?: ReviewStatus | undefined;
+        take?: number | undefined;
+        skip?: number | undefined;
+    }): Promise<{
+        reviews: Review[];
+        total: number;
+    }>;
+    hasReviewedProduct(customerId: string, productId: string): Promise<boolean>;
+    reportReview(params: {
+        reviewId: string;
+        reporterId?: string | undefined;
+        reason: string;
+        details?: string | undefined;
+    }): Promise<ReviewReport>;
+    listReports(params?: {
+        status?: ReportStatus | undefined;
+        reviewId?: string | undefined;
+        take?: number | undefined;
+        skip?: number | undefined;
+    }): Promise<ReviewReport[]>;
+    updateReportStatus(id: string, status: ReportStatus): Promise<ReviewReport | null>;
+    getReportCount(reviewId: string): Promise<number>;
+}
+export interface ReviewAnalytics {
+    totalReviews: number;
+    pendingCount: number;
+    approvedCount: number;
+    rejectedCount: number;
+    averageRating: number;
+    ratingsDistribution: Record<string, number>;
+    withMerchantResponse: number;
+    reportedCount: number;
+}
+export interface ReviewRequest {
+    id: string;
+    orderId: string;
+    orderNumber: string;
+    email: string;
+    customerName: string;
+    items: Array<{
+        productId: string;
+        name: string;
+    }>;
+    sentAt: Date;
+}
+export interface ReviewRequestStats {
+    totalSent: number;
+    uniqueOrders: number;
+}
+//# sourceMappingURL=service.d.ts.map