cmp-aws-database 2.1.2-proddebug.5 → 2.1.2-proddebug.6

package/dist/config/table-names.d.ts

@@ -20,6 +20,7 @@ export declare const BASE_TABLE_NAMES: {
     readonly INFLUENCER_PROMO: "InfluencerPromoTable";
     readonly INFLUENCER_REFERRAL: "InfluencerReferralTable";
     readonly CATALOGUE_ITEMS: "CatalogueItemsTable";
+    readonly BROWSE_HISTORY: "BrowseHistoryTable";
     readonly THIRD_PARTY_API_KEY: "ThirdPartyApiKeyTable";
     readonly ORDER: "OrderTable";
     readonly ORDER_ADDRESS: "OrderAddressTable";
@@ -80,6 +81,7 @@ export declare const TABLE_NAMES: {
     readonly INFLUENCER_PROMO: string;
     readonly INFLUENCER_REFERRAL: string;
     readonly CATALOGUE_ITEMS: string;
+    readonly BROWSE_HISTORY: string;
     readonly THIRD_PARTY_API_KEY: string;
     readonly ORDER: string;
     readonly ORDER_ADDRESS: string;

package/dist/config/table-names.js

@@ -26,6 +26,7 @@ exports.BASE_TABLE_NAMES = {
     INFLUENCER_PROMO: 'InfluencerPromoTable',
     INFLUENCER_REFERRAL: 'InfluencerReferralTable',
     CATALOGUE_ITEMS: 'CatalogueItemsTable',
+    BROWSE_HISTORY: 'BrowseHistoryTable',
     THIRD_PARTY_API_KEY: 'ThirdPartyApiKeyTable',
     // Order Module Tables
     ORDER: 'OrderTable',
@@ -101,6 +102,7 @@ exports.TABLE_NAMES = {
     INFLUENCER_PROMO: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.INFLUENCER_PROMO),
     INFLUENCER_REFERRAL: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.INFLUENCER_REFERRAL),
     CATALOGUE_ITEMS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CATALOGUE_ITEMS),
+    BROWSE_HISTORY: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.BROWSE_HISTORY),
     THIRD_PARTY_API_KEY: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.THIRD_PARTY_API_KEY),
     // Order Module Tables
     ORDER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER),
@@ -138,4 +140,4 @@ exports.TABLE_NAMES = {
     ACTIVITY_LOGS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ACTIVITY_LOGS),
     QUOTATIONS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.QUOTATIONS),
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-names.js","sourceRoot":"","sources":["../../src/config/table-names.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatabaseFactory } from './database-factory';\n\n// Base table names (without environment prefix)\nexport const BASE_TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: 'AppFeedbackTable',\n    LSQ_CRM: 'LsqCrmTable',\n    CUTLERY: 'CutleryTable',\n    ITEM_ACCOMPANIMENTS: 'ItemAccompanimentsTable',\n    CUISINE: 'CuisineTable',\n    TIER_DETAILS: 'TierDetailsTable',\n    USER_ORDER_SUMMARY: 'UserOrderSummaryTable',\n    TIER_REFERRAL: 'TierReferralTable',\n    USER_ADDRESS_REQUEST: 'UserAddressRequestTable',\n    COMMON_FEEDBACK: 'CommonFeedbackTable',\n    GUEST_FEEDBACK: 'GuestFeedbackTable',\n    COUNTER: 'CounterTable',\n    REQUEST_INVOICE: 'RequestInvoiceTable',\n    PLATTER_SEARCH_EVENTS: 'PlatterSearchEventsTable',\n    ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',\n    CATERING_REQUEST: 'CateringRequestTable',\n    FMP_REQUEST_CALLBACK: 'FmpRequestCallbackTable',\n    PLATTER_FIT: 'PlatterFitTable',\n    INFLUENCER_PROMO: 'InfluencerPromoTable',\n    INFLUENCER_REFERRAL: 'InfluencerReferralTable',\n    CATALOGUE_ITEMS: 'CatalogueItemsTable',\n    THIRD_PARTY_API_KEY: 'ThirdPartyApiKeyTable',\n\n    // Order Module Tables\n    ORDER: 'OrderTable',\n    ORDER_ADDRESS: 'OrderAddressTable',\n    ORDER_REVIEW: 'OrderReviewTable',\n    PAYMENT: 'PaymentTable',\n    PLATE_ORDER: 'PlateOrderTable',\n    TRACKING: 'TrackingTable',\n    USER_ADDRESS: 'UserAddressTable',\n    USER_SPECIFICS: 'UserSpecificsTable',\n    BBQ_SKEWERS: 'BbqSkewersTable',\n\n    // Other Customer Tables\n    ADD_ONS: 'AddOnsTable',\n    BANK_DETAILS: 'BankDetailsTable',\n    CART: 'CartTable',\n    CART_CATEGORIES: 'CartCategoriesTable',\n    CATEGORY: 'CategoryTable',\n    CATERING: 'CateringTable',\n    CONTENT: 'ContentTable',\n    COUPONS: 'CouponsTable',\n    DEFAULT_PLATTER: 'DefaultPlatterTable',\n    DEFAULT_PLATTER_CATEGORIES: 'DefaultPlatterCategoriesTable',\n    DEFAULT_PLATTER_ITEMS: 'DefaultPlatterItemsTable',\n    EVENT_EXECUTIVES: 'EventExecutivesTable',\n    ITEMS: 'ItemsTable',\n    LEAD: 'LeadTable',\n    OCCASION: 'OccasionTable',\n    REFERRAL_CONTENT: 'ReferralContentTable',\n    USER: 'UserTable',\n    WALLET: 'WalletTable',\n    WALLET_TRANSACTION: 'WalletTransactionTable',\n    WITHDRAWN: 'WithdrawnTable',\n\n    // Internal User Tables\n    INTERNAL_USER: 'InternalUserTable',\n    ACTIVITY_LOGS: 'ActivityLogsTable',\n    QUOTATIONS: 'QuotationsTable',\n} as const;\n\n// Environment-aware table name getter\nexport class TableNameManager {\n    public static getTableName(baseTableName: string): string {\n        return DatabaseFactory.getTableName(baseTableName);\n    }\n\n    public static getAllTableNames(): Record<string, string> {\n        const tableNames: Record<string, string> = {};\n\n        Object.entries(BASE_TABLE_NAMES).forEach(([key, value]) => {\n            tableNames[key] = this.getTableName(value);\n        });\n\n        return tableNames;\n    }\n}\n\n// Export environment-aware table names\nexport const TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.APP_FEEDBACK),\n    LSQ_CRM: TableNameManager.getTableName(BASE_TABLE_NAMES.LSQ_CRM),\n    CUTLERY: TableNameManager.getTableName(BASE_TABLE_NAMES.CUTLERY),\n    ITEM_ACCOMPANIMENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEM_ACCOMPANIMENTS),\n    CUISINE: TableNameManager.getTableName(BASE_TABLE_NAMES.CUISINE),\n    TIER_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_DETAILS),\n    USER_ORDER_SUMMARY: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ORDER_SUMMARY),\n    TIER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_REFERRAL),\n    USER_ADDRESS_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS_REQUEST),\n    COMMON_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.COMMON_FEEDBACK),\n    GUEST_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.GUEST_FEEDBACK),\n    COUNTER: TableNameManager.getTableName(BASE_TABLE_NAMES.COUNTER),\n    REQUEST_INVOICE: TableNameManager.getTableName(BASE_TABLE_NAMES.REQUEST_INVOICE),\n    PLATTER_SEARCH_EVENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_SEARCH_EVENTS),\n    ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),\n    CATERING_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING_REQUEST),\n    FMP_REQUEST_CALLBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.FMP_REQUEST_CALLBACK),\n    PLATTER_FIT: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_FIT),\n    INFLUENCER_PROMO: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_PROMO),\n    INFLUENCER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_REFERRAL),\n    CATALOGUE_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.CATALOGUE_ITEMS),\n    THIRD_PARTY_API_KEY: TableNameManager.getTableName(BASE_TABLE_NAMES.THIRD_PARTY_API_KEY),\n\n    // Order Module Tables\n    ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER),\n    ORDER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_ADDRESS),\n    ORDER_REVIEW: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW),\n    PAYMENT: TableNameManager.getTableName(BASE_TABLE_NAMES.PAYMENT),\n    PLATE_ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATE_ORDER),\n    TRACKING: TableNameManager.getTableName(BASE_TABLE_NAMES.TRACKING),\n    USER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS),\n    USER_SPECIFICS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_SPECIFICS),\n    BBQ_SKEWERS: TableNameManager.getTableName(BASE_TABLE_NAMES.BBQ_SKEWERS),\n\n    // Other Customer Tables\n    ADD_ONS: TableNameManager.getTableName(BASE_TABLE_NAMES.ADD_ONS),\n    BANK_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.BANK_DETAILS),\n    CART: TableNameManager.getTableName(BASE_TABLE_NAMES.CART),\n    CART_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.CART_CATEGORIES),\n    CATEGORY: TableNameManager.getTableName(BASE_TABLE_NAMES.CATEGORY),\n    CATERING: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING),\n    CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.CONTENT),\n    COUPONS: TableNameManager.getTableName(BASE_TABLE_NAMES.COUPONS),\n    DEFAULT_PLATTER: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER),\n    DEFAULT_PLATTER_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_CATEGORIES),\n    DEFAULT_PLATTER_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_ITEMS),\n    EVENT_EXECUTIVES: TableNameManager.getTableName(BASE_TABLE_NAMES.EVENT_EXECUTIVES),\n    ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEMS),\n    LEAD: TableNameManager.getTableName(BASE_TABLE_NAMES.LEAD),\n    OCCASION: TableNameManager.getTableName(BASE_TABLE_NAMES.OCCASION),\n    REFERRAL_CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.REFERRAL_CONTENT),\n    USER: TableNameManager.getTableName(BASE_TABLE_NAMES.USER),\n    WALLET: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET),\n    WALLET_TRANSACTION: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET_TRANSACTION),\n    WITHDRAWN: TableNameManager.getTableName(BASE_TABLE_NAMES.WITHDRAWN),\n\n    // Internal User Tables\n    INTERNAL_USER: TableNameManager.getTableName(BASE_TABLE_NAMES.INTERNAL_USER),\n    ACTIVITY_LOGS: TableNameManager.getTableName(BASE_TABLE_NAMES.ACTIVITY_LOGS),\n    QUOTATIONS: TableNameManager.getTableName(BASE_TABLE_NAMES.QUOTATIONS),\n} as const;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-names.js","sourceRoot":"","sources":["../../src/config/table-names.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatabaseFactory } from './database-factory';\n\n// Base table names (without environment prefix)\nexport const BASE_TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: 'AppFeedbackTable',\n    LSQ_CRM: 'LsqCrmTable',\n    CUTLERY: 'CutleryTable',\n    ITEM_ACCOMPANIMENTS: 'ItemAccompanimentsTable',\n    CUISINE: 'CuisineTable',\n    TIER_DETAILS: 'TierDetailsTable',\n    USER_ORDER_SUMMARY: 'UserOrderSummaryTable',\n    TIER_REFERRAL: 'TierReferralTable',\n    USER_ADDRESS_REQUEST: 'UserAddressRequestTable',\n    COMMON_FEEDBACK: 'CommonFeedbackTable',\n    GUEST_FEEDBACK: 'GuestFeedbackTable',\n    COUNTER: 'CounterTable',\n    REQUEST_INVOICE: 'RequestInvoiceTable',\n    PLATTER_SEARCH_EVENTS: 'PlatterSearchEventsTable',\n    ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',\n    CATERING_REQUEST: 'CateringRequestTable',\n    FMP_REQUEST_CALLBACK: 'FmpRequestCallbackTable',\n    PLATTER_FIT: 'PlatterFitTable',\n    INFLUENCER_PROMO: 'InfluencerPromoTable',\n    INFLUENCER_REFERRAL: 'InfluencerReferralTable',\n    CATALOGUE_ITEMS: 'CatalogueItemsTable',\n    BROWSE_HISTORY: 'BrowseHistoryTable',\n    THIRD_PARTY_API_KEY: 'ThirdPartyApiKeyTable',\n\n    // Order Module Tables\n    ORDER: 'OrderTable',\n    ORDER_ADDRESS: 'OrderAddressTable',\n    ORDER_REVIEW: 'OrderReviewTable',\n    PAYMENT: 'PaymentTable',\n    PLATE_ORDER: 'PlateOrderTable',\n    TRACKING: 'TrackingTable',\n    USER_ADDRESS: 'UserAddressTable',\n    USER_SPECIFICS: 'UserSpecificsTable',\n    BBQ_SKEWERS: 'BbqSkewersTable',\n\n    // Other Customer Tables\n    ADD_ONS: 'AddOnsTable',\n    BANK_DETAILS: 'BankDetailsTable',\n    CART: 'CartTable',\n    CART_CATEGORIES: 'CartCategoriesTable',\n    CATEGORY: 'CategoryTable',\n    CATERING: 'CateringTable',\n    CONTENT: 'ContentTable',\n    COUPONS: 'CouponsTable',\n    DEFAULT_PLATTER: 'DefaultPlatterTable',\n    DEFAULT_PLATTER_CATEGORIES: 'DefaultPlatterCategoriesTable',\n    DEFAULT_PLATTER_ITEMS: 'DefaultPlatterItemsTable',\n    EVENT_EXECUTIVES: 'EventExecutivesTable',\n    ITEMS: 'ItemsTable',\n    LEAD: 'LeadTable',\n    OCCASION: 'OccasionTable',\n    REFERRAL_CONTENT: 'ReferralContentTable',\n    USER: 'UserTable',\n    WALLET: 'WalletTable',\n    WALLET_TRANSACTION: 'WalletTransactionTable',\n    WITHDRAWN: 'WithdrawnTable',\n\n    // Internal User Tables\n    INTERNAL_USER: 'InternalUserTable',\n    ACTIVITY_LOGS: 'ActivityLogsTable',\n    QUOTATIONS: 'QuotationsTable',\n} as const;\n\n// Environment-aware table name getter\nexport class TableNameManager {\n    public static getTableName(baseTableName: string): string {\n        return DatabaseFactory.getTableName(baseTableName);\n    }\n\n    public static getAllTableNames(): Record<string, string> {\n        const tableNames: Record<string, string> = {};\n\n        Object.entries(BASE_TABLE_NAMES).forEach(([key, value]) => {\n            tableNames[key] = this.getTableName(value);\n        });\n\n        return tableNames;\n    }\n}\n\n// Export environment-aware table names\nexport const TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.APP_FEEDBACK),\n    LSQ_CRM: TableNameManager.getTableName(BASE_TABLE_NAMES.LSQ_CRM),\n    CUTLERY: TableNameManager.getTableName(BASE_TABLE_NAMES.CUTLERY),\n    ITEM_ACCOMPANIMENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEM_ACCOMPANIMENTS),\n    CUISINE: TableNameManager.getTableName(BASE_TABLE_NAMES.CUISINE),\n    TIER_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_DETAILS),\n    USER_ORDER_SUMMARY: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ORDER_SUMMARY),\n    TIER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_REFERRAL),\n    USER_ADDRESS_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS_REQUEST),\n    COMMON_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.COMMON_FEEDBACK),\n    GUEST_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.GUEST_FEEDBACK),\n    COUNTER: TableNameManager.getTableName(BASE_TABLE_NAMES.COUNTER),\n    REQUEST_INVOICE: TableNameManager.getTableName(BASE_TABLE_NAMES.REQUEST_INVOICE),\n    PLATTER_SEARCH_EVENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_SEARCH_EVENTS),\n    ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),\n    CATERING_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING_REQUEST),\n    FMP_REQUEST_CALLBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.FMP_REQUEST_CALLBACK),\n    PLATTER_FIT: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_FIT),\n    INFLUENCER_PROMO: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_PROMO),\n    INFLUENCER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_REFERRAL),\n    CATALOGUE_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.CATALOGUE_ITEMS),\n    BROWSE_HISTORY: TableNameManager.getTableName(BASE_TABLE_NAMES.BROWSE_HISTORY),\n    THIRD_PARTY_API_KEY: TableNameManager.getTableName(BASE_TABLE_NAMES.THIRD_PARTY_API_KEY),\n\n    // Order Module Tables\n    ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER),\n    ORDER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_ADDRESS),\n    ORDER_REVIEW: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW),\n    PAYMENT: TableNameManager.getTableName(BASE_TABLE_NAMES.PAYMENT),\n    PLATE_ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATE_ORDER),\n    TRACKING: TableNameManager.getTableName(BASE_TABLE_NAMES.TRACKING),\n    USER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS),\n    USER_SPECIFICS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_SPECIFICS),\n    BBQ_SKEWERS: TableNameManager.getTableName(BASE_TABLE_NAMES.BBQ_SKEWERS),\n\n    // Other Customer Tables\n    ADD_ONS: TableNameManager.getTableName(BASE_TABLE_NAMES.ADD_ONS),\n    BANK_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.BANK_DETAILS),\n    CART: TableNameManager.getTableName(BASE_TABLE_NAMES.CART),\n    CART_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.CART_CATEGORIES),\n    CATEGORY: TableNameManager.getTableName(BASE_TABLE_NAMES.CATEGORY),\n    CATERING: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING),\n    CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.CONTENT),\n    COUPONS: TableNameManager.getTableName(BASE_TABLE_NAMES.COUPONS),\n    DEFAULT_PLATTER: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER),\n    DEFAULT_PLATTER_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_CATEGORIES),\n    DEFAULT_PLATTER_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_ITEMS),\n    EVENT_EXECUTIVES: TableNameManager.getTableName(BASE_TABLE_NAMES.EVENT_EXECUTIVES),\n    ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEMS),\n    LEAD: TableNameManager.getTableName(BASE_TABLE_NAMES.LEAD),\n    OCCASION: TableNameManager.getTableName(BASE_TABLE_NAMES.OCCASION),\n    REFERRAL_CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.REFERRAL_CONTENT),\n    USER: TableNameManager.getTableName(BASE_TABLE_NAMES.USER),\n    WALLET: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET),\n    WALLET_TRANSACTION: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET_TRANSACTION),\n    WITHDRAWN: TableNameManager.getTableName(BASE_TABLE_NAMES.WITHDRAWN),\n\n    // Internal User Tables\n    INTERNAL_USER: TableNameManager.getTableName(BASE_TABLE_NAMES.INTERNAL_USER),\n    ACTIVITY_LOGS: TableNameManager.getTableName(BASE_TABLE_NAMES.ACTIVITY_LOGS),\n    QUOTATIONS: TableNameManager.getTableName(BASE_TABLE_NAMES.QUOTATIONS),\n} as const;\n"]}

package/dist/customer-user/browse-history/browse-history-dao.d.ts

@@ -0,0 +1,122 @@
+import { GenericDynamooseDAO } from "../../base-dynamoose-dao";
+import { AuthContext } from "../../base-dynamoose-model";
+import { BrowseHistory, CreateBrowseHistoryInput } from "./browse-history-model";
+type ListResult = {
+    items: BrowseHistory[];
+    nextToken?: string;
+};
+export type BrowseHistorySortField = "created_time" | "updated_time";
+export type BrowseHistorySortOrder = "asc" | "desc";
+/**
+ * DAO for user platter browse history.
+ *
+ * Table keys: `browsHistoryId` (PK).
+ * User lookup: query GSI `userIdIndex` by `userId`.
+ */
+declare class BrowseHistoryDao extends GenericDynamooseDAO<BrowseHistory> {
+    constructor();
+    /**
+     * Creates one browse-history record.
+     *
+     * Use when: user views a platter and you want to persist that browse event.
+     * - `browsHistoryId` auto-generates if omitted.
+     * - `userId` is required for later `getByUserId` / `listByUserId` lookups.
+     * - Stamps `created_time` / `created_user` automatically.
+     *
+     * @example
+     * await browsHistoryDao.save({
+     *     userId: "user-123",
+     *     platterId: "platter-abc",
+     *     platterName: "Birthday Feast",
+     *     platterType: "CATERING",
+     *     platterPrice: 4999,
+     *     totalItems: 12,
+     *     menuType: "VEG",
+     *     mealTime: "Dinner",
+     *     platterImage: "https://...",
+     *     replaceItemIds: [{ originalItemId: "item-1", replaceItemId: "item-2" }],
+     *     addonIds: [],
+     *     cutleryIds: [],
+     *     liveCounterIds: [],
+     *     skewerAddonIds: []
+     * }, { userSub: "user-123" });
+     */
+    save: (item: CreateBrowseHistoryInput, authContext?: AuthContext) => Promise<BrowseHistory>;
+    /**
+     * Updates one browse-history record by `browsHistoryId`.
+     *
+     * Use when: user re-visits same platter and you need to update selections or metadata.
+     * - Fails if the record does not exist.
+     * - Stamps `updated_time` / `updated_user` automatically.
+     *
+     * @example
+     * await browsHistoryDao.update(
+     *     "brows-history-uuid",
+     *     { addonIds: ["addon-1", "addon-2"], platterPrice: 5499 },
+     *     { userSub: "user-123" }
+     * );
+     */
+    update: (browseHistoryId: string, updates: Partial<BrowseHistory>, authContext?: AuthContext) => Promise<BrowseHistory>;
+    /**
+     * Fetches one browse-history record by primary key.
+     *
+     * Use when: detail screen already has `browsHistoryId` from a previous list response.
+     * Returns `null` when record is not found.
+     *
+     * @example
+     * const item = await browsHistoryDao.getById("brows-history-uuid");
+     */
+    getById: (browseHistoryId: string) => Promise<BrowseHistory | null>;
+    /**
+     * Returns browse-history for a user with optional sort and limit.
+     *
+     * Use when: showing "Recently Viewed" or full browse history on home/profile screen.
+     * - Queries all pages from GSI `userIdIndex`, then sorts in memory.
+     * - Pass `sortBy` as `"created_time"` or `"updated_time"` to order results.
+     * - Default `sortOrder` is `"desc"` (newest first).
+     * - `limit` is applied after sorting so latest N items are returned correctly.
+     *
+     * @example
+     * // Latest 10 browsed platters (most recently updated first)
+     * const recent = await browsHistoryDao.getByUserId("user-123", 10, "updated_time");
+     *
+     * @example
+     * // Oldest viewed first
+     * const oldestFirst = await browsHistoryDao.getByUserId("user-123", undefined, "created_time", "asc");
+     *
+     * @example
+     * // All history without sorting (raw DynamoDB order)
+     * const all = await browsHistoryDao.getByUserId("user-123");
+     */
+    getByUserId: (userId: string, limit?: number, sortBy?: BrowseHistorySortField, sortOrder?: BrowseHistorySortOrder) => Promise<BrowseHistory[]>;
+    /**
+     * Reads timestamp from audit field used for in-memory sorting.
+     */
+    private getBrowsHistorySortTime;
+    /**
+     * Sorts browse-history items by `created_time` or `updated_time`.
+     */
+    private sortBrowsHistoryItems;
+    /**
+     * Paginated query on GSI `userIdIndex`.
+     *
+     * Use when: infinite scroll / load-more UI where you pass `nextToken` from previous response.
+     * For sorted "recent N" views prefer `getByUserId` instead.
+     *
+     * @example
+     * const page1 = await browsHistoryDao.listByUserId("user-123", 20);
+     * const page2 = await browsHistoryDao.listByUserId("user-123", 20, page1.nextToken);
+     */
+    listByUserId: (userId: string, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Deletes one browse-history record by primary key.
+     *
+     * Use when: user clears a single item from browse history.
+     *
+     * @example
+     * await browsHistoryDao.deleteById("brows-history-uuid");
+     */
+    deleteById: (browsHistoryId: string) => Promise<void>;
+}
+export declare const browseHistoryDao: BrowseHistoryDao;
+export {};

package/dist/customer-user/browse-history/browse-history-dao.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseHistoryDao = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const base_dynamoose_dao_1 = require("../../base-dynamoose-dao");
+const browse_history_model_1 = require("./browse-history-model");
+/**
+ * DAO for user platter browse history.
+ *
+ * Table keys: `browsHistoryId` (PK).
+ * User lookup: query GSI `userIdIndex` by `userId`.
+ */
+class BrowseHistoryDao extends base_dynamoose_dao_1.GenericDynamooseDAO {
+    constructor() {
+        super(browse_history_model_1.BrowseHistoryModel, "browseHistoryId");
+        /**
+         * Creates one browse-history record.
+         *
+         * Use when: user views a platter and you want to persist that browse event.
+         * - `browsHistoryId` auto-generates if omitted.
+         * - `userId` is required for later `getByUserId` / `listByUserId` lookups.
+         * - Stamps `created_time` / `created_user` automatically.
+         *
+         * @example
+         * await browsHistoryDao.save({
+         *     userId: "user-123",
+         *     platterId: "platter-abc",
+         *     platterName: "Birthday Feast",
+         *     platterType: "CATERING",
+         *     platterPrice: 4999,
+         *     totalItems: 12,
+         *     menuType: "VEG",
+         *     mealTime: "Dinner",
+         *     platterImage: "https://...",
+         *     replaceItemIds: [{ originalItemId: "item-1", replaceItemId: "item-2" }],
+         *     addonIds: [],
+         *     cutleryIds: [],
+         *     liveCounterIds: [],
+         *     skewerAddonIds: []
+         * }, { userSub: "user-123" });
+         */
+        this.save = async (item, authContext) => {
+            return super.save(item, authContext);
+        };
+        /**
+         * Updates one browse-history record by `browsHistoryId`.
+         *
+         * Use when: user re-visits same platter and you need to update selections or metadata.
+         * - Fails if the record does not exist.
+         * - Stamps `updated_time` / `updated_user` automatically.
+         *
+         * @example
+         * await browsHistoryDao.update(
+         *     "brows-history-uuid",
+         *     { addonIds: ["addon-1", "addon-2"], platterPrice: 5499 },
+         *     { userSub: "user-123" }
+         * );
+         */
+        this.update = async (browseHistoryId, updates, authContext) => {
+            const updated = await browse_history_model_1.BrowseHistoryModel.update({ browseHistoryId }, {
+                ...updates,
+                updated_time: new Date(),
+                updated_user: authContext?.userSub
+            }, {
+                condition: new dynamoose_1.default.Condition().attribute("browseHistoryId").exists()
+            });
+            return updated;
+        };
+        /**
+         * Fetches one browse-history record by primary key.
+         *
+         * Use when: detail screen already has `browsHistoryId` from a previous list response.
+         * Returns `null` when record is not found.
+         *
+         * @example
+         * const item = await browsHistoryDao.getById("brows-history-uuid");
+         */
+        this.getById = async (browseHistoryId) => this.get(browseHistoryId);
+        /**
+         * Returns browse-history for a user with optional sort and limit.
+         *
+         * Use when: showing "Recently Viewed" or full browse history on home/profile screen.
+         * - Queries all pages from GSI `userIdIndex`, then sorts in memory.
+         * - Pass `sortBy` as `"created_time"` or `"updated_time"` to order results.
+         * - Default `sortOrder` is `"desc"` (newest first).
+         * - `limit` is applied after sorting so latest N items are returned correctly.
+         *
+         * @example
+         * // Latest 10 browsed platters (most recently updated first)
+         * const recent = await browsHistoryDao.getByUserId("user-123", 10, "updated_time");
+         *
+         * @example
+         * // Oldest viewed first
+         * const oldestFirst = await browsHistoryDao.getByUserId("user-123", undefined, "created_time", "asc");
+         *
+         * @example
+         * // All history without sorting (raw DynamoDB order)
+         * const all = await browsHistoryDao.getByUserId("user-123");
+         */
+        this.getByUserId = async (userId, limit, sortBy, sortOrder = "desc") => {
+            const items = [];
+            let token;
+            do {
+                const result = await this.listByUserId(userId, undefined, token);
+                items.push(...result.items);
+                token = result.nextToken;
+            } while (token);
+            const sortedItems = this.sortBrowsHistoryItems(items, sortBy, sortOrder);
+            return typeof limit === "number" ? sortedItems.slice(0, limit) : sortedItems;
+        };
+        /**
+         * Reads timestamp from audit field used for in-memory sorting.
+         */
+        this.getBrowsHistorySortTime = (item, field) => {
+            const value = item[field];
+            if (!value) {
+                return 0;
+            }
+            return value instanceof Date ? value.getTime() : new Date(value).getTime();
+        };
+        /**
+         * Sorts browse-history items by `created_time` or `updated_time`.
+         */
+        this.sortBrowsHistoryItems = (items, sortBy, sortOrder = "desc") => {
+            if (!sortBy) {
+                return items;
+            }
+            const direction = sortOrder === "asc" ? 1 : -1;
+            return [...items].sort((a, b) => (this.getBrowsHistorySortTime(a, sortBy) - this.getBrowsHistorySortTime(b, sortBy)) * direction);
+        };
+        /**
+         * Paginated query on GSI `userIdIndex`.
+         *
+         * Use when: infinite scroll / load-more UI where you pass `nextToken` from previous response.
+         * For sorted "recent N" views prefer `getByUserId` instead.
+         *
+         * @example
+         * const page1 = await browsHistoryDao.listByUserId("user-123", 20);
+         * const page2 = await browsHistoryDao.listByUserId("user-123", 20, page1.nextToken);
+         */
+        this.listByUserId = async (userId, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = browse_history_model_1.BrowseHistoryModel.query("userId").eq(userId).using("userIdIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Deletes one browse-history record by primary key.
+         *
+         * Use when: user clears a single item from browse history.
+         *
+         * @example
+         * await browsHistoryDao.deleteById("brows-history-uuid");
+         */
+        this.deleteById = async (browsHistoryId) => {
+            await this.delete(browsHistoryId);
+        };
+    }
+}
+exports.browseHistoryDao = new BrowseHistoryDao();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browse-history-dao.js","sourceRoot":"","sources":["../../../src/customer-user/browse-history/browse-history-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import dynamoose from \"dynamoose\";\nimport { DynamoKey, GenericDynamooseDAO } from \"../../base-dynamoose-dao\";\nimport { AuthContext } from \"../../base-dynamoose-model\";\nimport {\n    BrowseHistory,\n    BrowseHistoryModel,\n    CreateBrowseHistoryInput\n} from \"./browse-history-model\";\n\ntype ListResult = {\n    items: BrowseHistory[];\n    nextToken?: string;\n};\n\nexport type BrowseHistorySortField = \"created_time\" | \"updated_time\";\nexport type BrowseHistorySortOrder = \"asc\" | \"desc\";\n\n/**\n * DAO for user platter browse history.\n *\n * Table keys: `browsHistoryId` (PK).\n * User lookup: query GSI `userIdIndex` by `userId`.\n */\nclass BrowseHistoryDao extends GenericDynamooseDAO<BrowseHistory> {\n    constructor() {\n        super(BrowseHistoryModel, \"browseHistoryId\");\n    }\n\n    /**\n     * Creates one browse-history record.\n     *\n     * Use when: user views a platter and you want to persist that browse event.\n     * - `browsHistoryId` auto-generates if omitted.\n     * - `userId` is required for later `getByUserId` / `listByUserId` lookups.\n     * - Stamps `created_time` / `created_user` automatically.\n     *\n     * @example\n     * await browsHistoryDao.save({\n     *     userId: \"user-123\",\n     *     platterId: \"platter-abc\",\n     *     platterName: \"Birthday Feast\",\n     *     platterType: \"CATERING\",\n     *     platterPrice: 4999,\n     *     totalItems: 12,\n     *     menuType: \"VEG\",\n     *     mealTime: \"Dinner\",\n     *     platterImage: \"https://...\",\n     *     replaceItemIds: [{ originalItemId: \"item-1\", replaceItemId: \"item-2\" }],\n     *     addonIds: [],\n     *     cutleryIds: [],\n     *     liveCounterIds: [],\n     *     skewerAddonIds: []\n     * }, { userSub: \"user-123\" });\n     */\n    save = async (item: CreateBrowseHistoryInput, authContext?: AuthContext): Promise<BrowseHistory> => {\n        return super.save(item as BrowseHistory, authContext);\n    };\n\n    /**\n     * Updates one browse-history record by `browsHistoryId`.\n     *\n     * Use when: user re-visits same platter and you need to update selections or metadata.\n     * - Fails if the record does not exist.\n     * - Stamps `updated_time` / `updated_user` automatically.\n     *\n     * @example\n     * await browsHistoryDao.update(\n     *     \"brows-history-uuid\",\n     *     { addonIds: [\"addon-1\", \"addon-2\"], platterPrice: 5499 },\n     *     { userSub: \"user-123\" }\n     * );\n     */\n    update = async (\n        browseHistoryId: string,\n        updates: Partial<BrowseHistory>,\n        authContext?: AuthContext\n    ): Promise<BrowseHistory> => {\n        const updated = await BrowseHistoryModel.update(\n            { browseHistoryId },\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            },\n            {\n                condition: new dynamoose.Condition().attribute(\"browseHistoryId\").exists()\n            }\n        );\n        return updated as unknown as BrowseHistory;\n    };\n\n    /**\n     * Fetches one browse-history record by primary key.\n     *\n     * Use when: detail screen already has `browsHistoryId` from a previous list response.\n     * Returns `null` when record is not found.\n     *\n     * @example\n     * const item = await browsHistoryDao.getById(\"brows-history-uuid\");\n     */\n    getById = async (browseHistoryId: string): Promise<BrowseHistory | null> => this.get(browseHistoryId);\n\n    /**\n     * Returns browse-history for a user with optional sort and limit.\n     *\n     * Use when: showing \"Recently Viewed\" or full browse history on home/profile screen.\n     * - Queries all pages from GSI `userIdIndex`, then sorts in memory.\n     * - Pass `sortBy` as `\"created_time\"` or `\"updated_time\"` to order results.\n     * - Default `sortOrder` is `\"desc\"` (newest first).\n     * - `limit` is applied after sorting so latest N items are returned correctly.\n     *\n     * @example\n     * // Latest 10 browsed platters (most recently updated first)\n     * const recent = await browsHistoryDao.getByUserId(\"user-123\", 10, \"updated_time\");\n     *\n     * @example\n     * // Oldest viewed first\n     * const oldestFirst = await browsHistoryDao.getByUserId(\"user-123\", undefined, \"created_time\", \"asc\");\n     *\n     * @example\n     * // All history without sorting (raw DynamoDB order)\n     * const all = await browsHistoryDao.getByUserId(\"user-123\");\n     */\n    getByUserId = async (\n        userId: string,\n        limit?: number,\n        sortBy?: BrowseHistorySortField,\n        sortOrder: BrowseHistorySortOrder = \"desc\"\n    ): Promise<BrowseHistory[]> => {\n        const items: BrowseHistory[] = [];\n        let token: string | undefined;\n\n        do {\n            const result = await this.listByUserId(userId, undefined, token);\n            items.push(...result.items);\n            token = result.nextToken;\n        } while (token);\n\n        const sortedItems = this.sortBrowsHistoryItems(items, sortBy, sortOrder);\n        return typeof limit === \"number\" ? sortedItems.slice(0, limit) : sortedItems;\n    };\n\n    /**\n     * Reads timestamp from audit field used for in-memory sorting.\n     */\n    private getBrowsHistorySortTime = (item: BrowseHistory, field: BrowseHistorySortField): number => {\n        const value = item[field];\n        if (!value) {\n            return 0;\n        }\n        return value instanceof Date ? value.getTime() : new Date(value).getTime();\n    };\n\n    /**\n     * Sorts browse-history items by `created_time` or `updated_time`.\n     */\n    private sortBrowsHistoryItems = (\n        items: BrowseHistory[],\n        sortBy?: BrowseHistorySortField,\n        sortOrder: BrowseHistorySortOrder = \"desc\"\n    ): BrowseHistory[] => {\n        if (!sortBy) {\n            return items;\n        }\n\n        const direction = sortOrder === \"asc\" ? 1 : -1;\n        return [...items].sort(\n            (a, b) => (this.getBrowsHistorySortTime(a, sortBy) - this.getBrowsHistorySortTime(b, sortBy)) * direction\n        );\n    };\n\n    /**\n     * Paginated query on GSI `userIdIndex`.\n     *\n     * Use when: infinite scroll / load-more UI where you pass `nextToken` from previous response.\n     * For sorted \"recent N\" views prefer `getByUserId` instead.\n     *\n     * @example\n     * const page1 = await browsHistoryDao.listByUserId(\"user-123\", 20);\n     * const page2 = await browsHistoryDao.listByUserId(\"user-123\", 20, page1.nextToken);\n     */\n    listByUserId = async (userId: string, limit?: number, token?: string): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = BrowseHistoryModel.query(\"userId\").eq(userId).using(\"userIdIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as BrowseHistory[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Deletes one browse-history record by primary key.\n     *\n     * Use when: user clears a single item from browse history.\n     *\n     * @example\n     * await browsHistoryDao.deleteById(\"brows-history-uuid\");\n     */\n    deleteById = async (browsHistoryId: string): Promise<void> => {\n        await this.delete(browsHistoryId);\n    };\n}\n\nexport const browseHistoryDao = new BrowseHistoryDao();\n"]}

package/dist/customer-user/browse-history/browse-history-model.d.ts

@@ -0,0 +1,29 @@
+import { BaseDynamooseModel } from "../../base-dynamoose-model";
+export interface BrowseHistoryReplaceItem {
+    originalItemId: string;
+    replaceItemId: string;
+}
+export interface BrowseHistory extends BaseDynamooseModel {
+    browseHistoryId: string;
+    userId: string;
+    resumeJourneyId: string;
+    platterId: string;
+    platterName: string;
+    platterType: string;
+    platterSubType?: string;
+    platterPrice: number;
+    totalItems: number;
+    menuType: string;
+    mealTime: string;
+    platterImage: string;
+    replaceItemIds: BrowseHistoryReplaceItem[];
+    addonIds: string[];
+    cutleryIds: string[];
+    liveCounterIds: string[];
+    skewerAddonIds: string[];
+}
+export type CreateBrowseHistoryInput = Omit<BrowseHistory, "browseHistoryId"> & {
+    browseHistoryId?: string;
+};
+export declare const BrowseHistoryModel: import("dynamoose/dist/General").ModelType<BrowseHistory>;
+export declare const convertToBrowseHistoryModel: (input: CreateBrowseHistoryInput | BrowseHistory) => BrowseHistory;

package/dist/customer-user/browse-history/browse-history-model.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToBrowseHistoryModel = exports.BrowseHistoryModel = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const crypto_1 = require("crypto");
+const base_dynamoose_model_1 = require("../../base-dynamoose-model");
+const table_names_1 = require("../../config/table-names");
+const browseHistorySchema = new dynamoose_1.default.Schema({
+    browseHistoryId: {
+        type: String,
+        hashKey: true,
+        required: true,
+        default: () => (0, crypto_1.randomUUID)()
+    },
+    userId: {
+        type: String,
+        required: true,
+        index: {
+            name: "userIdIndex",
+            type: "global"
+        }
+    },
+    resumeJourneyId: {
+        type: String,
+        required: true
+    },
+    platterId: {
+        type: String,
+        required: true
+    },
+    platterName: {
+        type: String,
+        required: true
+    },
+    platterType: {
+        type: String,
+        required: true
+    },
+    platterSubType: String,
+    platterPrice: {
+        type: Number,
+        required: true
+    },
+    totalItems: {
+        type: Number,
+        required: true
+    },
+    menuType: {
+        type: String,
+        required: true
+    },
+    mealTime: {
+        type: String,
+        required: true
+    },
+    platterImage: {
+        type: String,
+        required: true
+    },
+    replaceItemIds: {
+        type: Array,
+        schema: [{
+                type: Object,
+                schema: {
+                    originalItemId: {
+                        type: String,
+                        required: true
+                    },
+                    replaceItemId: {
+                        type: String,
+                        required: true
+                    }
+                }
+            }],
+        default: []
+    },
+    addonIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    cutleryIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    liveCounterIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    skewerAddonIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    ...base_dynamoose_model_1.BASE_DYNAMOOSE_AUDIT_SCHEMA
+}, {
+    saveUnknown: false,
+    timestamps: true
+});
+exports.BrowseHistoryModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.BROWSE_HISTORY, browseHistorySchema, { create: false, waitForActive: false });
+const convertToBrowseHistoryModel = (input) => {
+    return new exports.BrowseHistoryModel(input);
+};
+exports.convertToBrowseHistoryModel = convertToBrowseHistoryModel;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/cutlery/cutlery-model.d.ts

@@ -15,4 +15,5 @@ export declare class CutleryModel extends BaseModel {
     isIncluded?: boolean;
     isServing?: boolean;
     isInfo?: boolean;
+    isUpgradedCutlery?: boolean;
 }

package/dist/customer-user/cutlery/cutlery-model.js

@@ -75,7 +75,11 @@ __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", Boolean)
 ], CutleryModel.prototype, "isInfo", void 0);
+__decorate([
+    (0, annotations_1.attribute)(),
+    __metadata("design:type", Boolean)
+], CutleryModel.prototype, "isUpgradedCutlery", void 0);
 exports.CutleryModel = CutleryModel = __decorate([
     (0, annotations_1.table)("CutleryTable")
 ], CutleryModel);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/resume-journey/resume-journey-model.d.ts

@@ -35,4 +35,5 @@ export declare class ResumeJourneyModel extends BaseModel {
     celebrationImage?: string | null;
     vegGuestCount?: number | null;
     addressId?: string | null;
+    eventTime?: string | null;
 }

package/dist/customer-user/resume-journey/resume-journey-model.js

@@ -123,7 +123,11 @@ __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", Object)
 ], ResumeJourneyModel.prototype, "addressId", void 0);
+__decorate([
+    (0, annotations_1.attribute)(),
+    __metadata("design:type", Object)
+], ResumeJourneyModel.prototype, "eventTime", void 0);
 exports.ResumeJourneyModel = ResumeJourneyModel = __decorate([
     (0, annotations_1.table)("ResumeJourneyTable")
 ], ResumeJourneyModel);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmp-aws-database",
-  "version": "2.1.2-proddebug.5",
+  "version": "2.1.2-proddebug.6",
   "bin": {
     "craft-my-plate-database": "bin/craft-my-plate-database.js"
   },