@daffodil/category 0.38.9 → 0.39.0

package/bundles/daffodil-category-state.umd.js

@@ -4,34 +4,22 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.daffodil = global.daffodil || {}, global.daffodil.category = global.daffodil.category || {}, global.daffodil.category.state = {}), global.ng.core, global.i1, global.state, global.entity, global.daffodil.category, global.effects, global.rxjs, global.rxjs.operators, global.daffodil.category.driver));
 }(this, (function (exports, i0, i1, state, entity, category, effects, rxjs, operators, driver) { 'use strict';
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: reducers/category-entities/category-entities-adapter.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @return {?}
-     */
     function daffCategoryEntitiesAdapter() {
         return entity.createEntityAdapter();
     }
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: actions/category-page.actions.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * The possible types of category page actions.
      */
-    /** @enum {string} */
-    var DaffCategoryPageActionTypes = {
-        CategoryPageLoadAction: "[@daffodil/category] Category Page Load Action",
-        CategoryPageLoadByUrlAction: "[@daffodil/category] Category Page Load By URL Action",
-        CategoryPageLoadSuccessAction: "[@daffodil/category] Category Page Load Success Action",
-        CategoryPageLoadFailureAction: "[@daffodil/category] Category Page Load Failure Action",
-        CategoryPageChangeSizeAction: "[@daffodil/category] Category Page Change Size Action",
-        CategoryPageChangeCurrentPageAction: "[@daffodil/category] Category Page Change Current Page Action",
-        CategoryPageChangeSortingOptionAction: "[@daffodil/category] Category Page Change Sorting Option Action",
-    };
+    (function (DaffCategoryPageActionTypes) {
+        DaffCategoryPageActionTypes["CategoryPageLoadAction"] = "[@daffodil/category] Category Page Load Action";
+        DaffCategoryPageActionTypes["CategoryPageLoadByUrlAction"] = "[@daffodil/category] Category Page Load By URL Action";
+        DaffCategoryPageActionTypes["CategoryPageLoadSuccessAction"] = "[@daffodil/category] Category Page Load Success Action";
+        DaffCategoryPageActionTypes["CategoryPageLoadFailureAction"] = "[@daffodil/category] Category Page Load Failure Action";
+        DaffCategoryPageActionTypes["CategoryPageChangeSizeAction"] = "[@daffodil/category] Category Page Change Size Action";
+        DaffCategoryPageActionTypes["CategoryPageChangeCurrentPageAction"] = "[@daffodil/category] Category Page Change Current Page Action";
+        DaffCategoryPageActionTypes["CategoryPageChangeSortingOptionAction"] = "[@daffodil/category] Category Page Change Sorting Option Action";
+    })(exports.DaffCategoryPageActionTypes || (exports.DaffCategoryPageActionTypes = {}));
     /**
      * An action triggered to initialize a category page load request.
      * This is intended to be used for loading full category pages.
@@ -40,21 +28,12 @@
      * @param request - DaffCategoryRequest object
      */
     var DaffCategoryPageLoad = /** @class */ (function () {
-        /**
-         * @param {?} request
-         */
         function DaffCategoryPageLoad(request) {
             this.request = request;
-            this.type = DaffCategoryPageActionTypes.CategoryPageLoadAction;
+            this.type = exports.DaffCategoryPageActionTypes.CategoryPageLoadAction;
         }
         return DaffCategoryPageLoad;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageLoad.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageLoad.prototype.request;
-    }
     /**
      * An action triggered to initialize a category page load request.
      * This is intended to be used for loading full category pages.
@@ -63,221 +42,126 @@
      * @param request - DaffCategoryRequest object
      */
     var DaffCategoryPageLoadByUrl = /** @class */ (function () {
-        /**
-         * @param {?} request
-         */
         function DaffCategoryPageLoadByUrl(request) {
             this.request = request;
-            this.type = DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction;
+            this.type = exports.DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction;
         }
         return DaffCategoryPageLoadByUrl;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageLoadByUrl.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageLoadByUrl.prototype.request;
-    }
     /**
      * An action triggered upon a successful category page request.
      *
      * @param response - DaffGetCategoryResponse object
-     * @template V, W
      */
     var DaffCategoryPageLoadSuccess = /** @class */ (function () {
-        /**
-         * @param {?} response
-         */
         function DaffCategoryPageLoadSuccess(response) {
             this.response = response;
-            this.type = DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction;
+            this.type = exports.DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction;
         }
         return DaffCategoryPageLoadSuccess;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageLoadSuccess.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageLoadSuccess.prototype.response;
-    }
     /**
      * An action triggered upon a failed category page request.
      *
      * @param errorMessage - an error message
      */
     var DaffCategoryPageLoadFailure = /** @class */ (function () {
-        /**
-         * @param {?} errorMessage
-         */
         function DaffCategoryPageLoadFailure(errorMessage) {
             this.errorMessage = errorMessage;
-            this.type = DaffCategoryPageActionTypes.CategoryPageLoadFailureAction;
+            this.type = exports.DaffCategoryPageActionTypes.CategoryPageLoadFailureAction;
         }
         return DaffCategoryPageLoadFailure;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageLoadFailure.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageLoadFailure.prototype.errorMessage;
-    }
     /**
      * An action for changing the number of products shown on each page for the selected category.
      *
      * @param pageSize - The number of products per page.
      */
     var DaffCategoryPageChangePageSize = /** @class */ (function () {
-        /**
-         * @param {?} pageSize
-         */
         function DaffCategoryPageChangePageSize(pageSize) {
             this.pageSize = pageSize;
-            this.type = DaffCategoryPageActionTypes.CategoryPageChangeSizeAction;
+            this.type = exports.DaffCategoryPageActionTypes.CategoryPageChangeSizeAction;
         }
         return DaffCategoryPageChangePageSize;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageChangePageSize.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageChangePageSize.prototype.pageSize;
-    }
     /**
      * An action for changing the current page of products for the selected category.
      *
      * @param currentPage - The current page of products for the selected category.
      */
     var DaffCategoryPageChangeCurrentPage = /** @class */ (function () {
-        /**
-         * @param {?} currentPage
-         */
         function DaffCategoryPageChangeCurrentPage(currentPage) {
             this.currentPage = currentPage;
-            this.type = DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction;
+            this.type = exports.DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction;
         }
         return DaffCategoryPageChangeCurrentPage;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageChangeCurrentPage.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageChangeCurrentPage.prototype.currentPage;
-    }
     /**
      * An action for changing the sorting option for the selected category.
      *
      * @param sort - The sort option to be applied.
      */
     var DaffCategoryPageChangeSortingOption = /** @class */ (function () {
-        /**
-         * @param {?} sort
-         */
         function DaffCategoryPageChangeSortingOption(sort) {
             this.sort = sort;
-            this.type = DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction;
+            this.type = exports.DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction;
         }
         return DaffCategoryPageChangeSortingOption;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageChangeSortingOption.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageChangeSortingOption.prototype.sort;
-    }
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: actions/category.actions.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * The possible types of category actions.
      */
-    /** @enum {string} */
-    var DaffCategoryActionTypes = {
-        CategoryLoadAction: "[Daff-Category] Category Load Action",
-        CategoryLoadSuccessAction: "[Daff-Category] Category Load Success Action",
-        CategoryLoadFailureAction: "[Daff-Category] Category Load Failure Action",
-    };
+    (function (DaffCategoryActionTypes) {
+        DaffCategoryActionTypes["CategoryLoadAction"] = "[Daff-Category] Category Load Action";
+        DaffCategoryActionTypes["CategoryLoadSuccessAction"] = "[Daff-Category] Category Load Success Action";
+        DaffCategoryActionTypes["CategoryLoadFailureAction"] = "[Daff-Category] Category Load Failure Action";
+    })(exports.DaffCategoryActionTypes || (exports.DaffCategoryActionTypes = {}));
     /**
      * An action triggered to initialize a category load request.
      *
      * @param request - DaffCategoryRequest object
      */
     var DaffCategoryLoad = /** @class */ (function () {
-        /**
-         * @param {?} request
-         */
         function DaffCategoryLoad(request) {
             this.request = request;
-            this.type = DaffCategoryActionTypes.CategoryLoadAction;
+            this.type = exports.DaffCategoryActionTypes.CategoryLoadAction;
         }
         return DaffCategoryLoad;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryLoad.prototype.type;
-        /** @type {?} */
-        DaffCategoryLoad.prototype.request;
-    }
     /**
      * An action triggered upon a successful category request.
      *
      * @param response - DaffGetCategoryResponse object
-     * @template V, W
      */
     var DaffCategoryLoadSuccess = /** @class */ (function () {
-        /**
-         * @param {?} response
-         */
         function DaffCategoryLoadSuccess(response) {
             this.response = response;
-            this.type = DaffCategoryActionTypes.CategoryLoadSuccessAction;
+            this.type = exports.DaffCategoryActionTypes.CategoryLoadSuccessAction;
         }
         return DaffCategoryLoadSuccess;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryLoadSuccess.prototype.type;
-        /** @type {?} */
-        DaffCategoryLoadSuccess.prototype.response;
-    }
     /**
      * An action triggered upon a failed category request.
      *
      * @param errorMessage - an error message
      */
     var DaffCategoryLoadFailure = /** @class */ (function () {
-        /**
-         * @param {?} errorMessage
-         */
         function DaffCategoryLoadFailure(errorMessage) {
             this.errorMessage = errorMessage;
-            this.type = DaffCategoryActionTypes.CategoryLoadFailureAction;
+            this.type = exports.DaffCategoryActionTypes.CategoryLoadFailureAction;
         }
         return DaffCategoryLoadFailure;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryLoadFailure.prototype.type;
-        /** @type {?} */
-        DaffCategoryLoadFailure.prototype.errorMessage;
-    }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: reducers/category-entities/category-entities.reducer.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * A reducer function to store category entities from DaffCategoryLoadSuccess and DaffCategoryPageLoadSuccess actions.
-     * @template V, W
-     * @param {?=} state
-     * @param {?=} action
-     * @return {?}
      */
     function daffCategoryEntitiesReducer(state, action) {
         if (state === void 0) { state = daffCategoryEntitiesAdapter().getInitialState(); }
         switch (action.type) {
-            case DaffCategoryActionTypes.CategoryLoadSuccessAction:
-            case DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction:
+            case exports.DaffCategoryActionTypes.CategoryLoadSuccessAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction:
                 return daffCategoryEntitiesAdapter().upsertOne(Object.assign({ id: action.response.category.id }, action.response.category), state);
             default:
                 return state;
@@ -285,41 +169,29 @@
     }
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: actions/category-page-filter.actions.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * The possible types of category page filter actions.
      */
-    /** @enum {string} */
-    var DaffCategoryPageFilterActionTypes = {
-        CategoryPageChangeFiltersAction: "[@daffodil/category] Category Page Change Filters Action",
-        CategoryPageReplaceFiltersAction: "[@daffodil/category] Category Page Replace Filters Action",
-        CategoryPageApplyFiltersAction: "[@daffodil/category] Category Page Apply Filters Action",
-        CategoryPageRemoveFiltersAction: "[@daffodil/category] Category Page Remove Filters Action",
-        CategoryPageClearFiltersAction: "[@daffodil/category] Category Page Clear Filters Action",
-        CategoryPageToggleFilterAction: "[@daffodil/category] Category Page Toggle Filter Action",
-    };
+    (function (DaffCategoryPageFilterActionTypes) {
+        DaffCategoryPageFilterActionTypes["CategoryPageChangeFiltersAction"] = "[@daffodil/category] Category Page Change Filters Action";
+        DaffCategoryPageFilterActionTypes["CategoryPageReplaceFiltersAction"] = "[@daffodil/category] Category Page Replace Filters Action";
+        DaffCategoryPageFilterActionTypes["CategoryPageApplyFiltersAction"] = "[@daffodil/category] Category Page Apply Filters Action";
+        DaffCategoryPageFilterActionTypes["CategoryPageRemoveFiltersAction"] = "[@daffodil/category] Category Page Remove Filters Action";
+        DaffCategoryPageFilterActionTypes["CategoryPageClearFiltersAction"] = "[@daffodil/category] Category Page Clear Filters Action";
+        DaffCategoryPageFilterActionTypes["CategoryPageToggleFilterAction"] = "[@daffodil/category] Category Page Toggle Filter Action";
+    })(exports.DaffCategoryPageFilterActionTypes || (exports.DaffCategoryPageFilterActionTypes = {}));
     /**
      * An action for changing the filters for the current category.
      *
      * @param filters - Filters to be changed on the current category.
-     * @deprecated use {\@link DaffCategoryPageReplaceFilters} or {\@link DaffCategoryPageApplyFilters}
+     * @deprecated use {@link DaffCategoryPageReplaceFilters} or {@link DaffCategoryPageApplyFilters}
      */
     var DaffCategoryPageChangeFilters = /** @class */ (function () {
-        /**
-         * @param {?} filters
-         */
         function DaffCategoryPageChangeFilters(filters) {
             this.filters = filters;
-            this.type = DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction;
+            this.type = exports.DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction;
         }
         return DaffCategoryPageChangeFilters;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageChangeFilters.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageChangeFilters.prototype.filters;
-    }
     /**
      * An action for replacing the filters for the current category.
      * All existing filters will be removed and the specified filters will be applied.
@@ -327,132 +199,71 @@
      * @param filters - Filters to be set on the current category.
      */
     var DaffCategoryPageReplaceFilters = /** @class */ (function () {
-        /**
-         * @param {?} filters
-         */
         function DaffCategoryPageReplaceFilters(filters) {
             this.filters = filters;
-            this.type = DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction;
+            this.type = exports.DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction;
         }
         return DaffCategoryPageReplaceFilters;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageReplaceFilters.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageReplaceFilters.prototype.filters;
-    }
     /**
      * An action for applying the specified filters for the current category.
      *
      * @param filters - Filters to be applied to the current category.
      */
     var DaffCategoryPageApplyFilters = /** @class */ (function () {
-        /**
-         * @param {?} filters
-         */
         function DaffCategoryPageApplyFilters(filters) {
             this.filters = filters;
-            this.type = DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction;
+            this.type = exports.DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction;
         }
         return DaffCategoryPageApplyFilters;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageApplyFilters.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageApplyFilters.prototype.filters;
-    }
     /**
      * An action for removing the specified filters for the current category.
      *
      * @param filters - Filters to be removed from the current category.
      */
     var DaffCategoryPageRemoveFilters = /** @class */ (function () {
-        /**
-         * @param {?} filters
-         */
         function DaffCategoryPageRemoveFilters(filters) {
             this.filters = filters;
-            this.type = DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction;
+            this.type = exports.DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction;
         }
         return DaffCategoryPageRemoveFilters;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageRemoveFilters.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageRemoveFilters.prototype.filters;
-    }
     /**
      * An action for removing all the filters for the current category.
      */
     var DaffCategoryPageClearFilters = /** @class */ (function () {
         function DaffCategoryPageClearFilters() {
-            this.type = DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction;
+            this.type = exports.DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction;
         }
         return DaffCategoryPageClearFilters;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageClearFilters.prototype.type;
-    }
     /**
      * An action for toggling a filters for the current category.
      *
      * @param filter - Filter to be toggled on the current category.
      */
     var DaffCategoryPageToggleFilter = /** @class */ (function () {
-        /**
-         * @param {?} filter
-         */
         function DaffCategoryPageToggleFilter(filter) {
             this.filter = filter;
-            this.type = DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction;
+            this.type = exports.DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction;
         }
         return DaffCategoryPageToggleFilter;
     }());
-    if (false) {
-        /** @type {?} */
-        DaffCategoryPageToggleFilter.prototype.type;
-        /** @type {?} */
-        DaffCategoryPageToggleFilter.prototype.filter;
-    }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: reducers/category/pure/build-metadata-from-request.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
     var allowedMetadataKeys = [
         'applied_sort_option',
         'applied_sort_direction',
         'current_page',
         'page_size',
     ];
-    /** @type {?} */
-    var buildMetadataFromRequest = ( /**
-     * @param {?} request
-     * @return {?}
-     */function (request) { return allowedMetadataKeys.reduce(( /**
-     * @template K
-     * @param {?} acc
-     * @param {?} key
-     * @return {?}
-     */function (acc, key) {
+    var buildMetadataFromRequest = function (request) { return allowedMetadataKeys.reduce(function (acc, key) {
         if (request[key]) {
             acc[key] = request[key];
         }
         return acc;
-    }), ( /** @type {?} */({}))); });
+    }, {}); };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: reducers/category/category.reducer.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
     var initialState = {
         categoryPageMetadata: {
             id: null,
@@ -476,166 +287,70 @@
     };
     /**
      * Returns the state for category data except for category entities.
-     * @template U, W
-     * @param {?=} state
-     * @param {?=} action
-     * @return {?}
      */
     function daffCategoryReducer(state, action) {
         if (state === void 0) { state = initialState; }
         switch (action.type) {
-            case DaffCategoryPageActionTypes.CategoryPageLoadAction:
-            case DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageLoadAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction:
                 return Object.assign(Object.assign({}, state), { categoryLoading: true, productsLoading: true, daffState: "Resolving" /* Resolving */, categoryPageMetadata: Object.assign(Object.assign(Object.assign({}, initialState.categoryPageMetadata), buildMetadataFromRequest(action.request)), { id: null }) });
-            case DaffCategoryPageActionTypes.CategoryPageChangeSizeAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageChangeSizeAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { page_size: action.pageSize }) });
-            case DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { current_page: action.currentPage }) });
-            case DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { applied_sort_option: action.sort.option, applied_sort_direction: action.sort.direction }) });
-            case DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction:
-            case DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction:
+            case exports.DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction:
+            case exports.DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { filters: category.daffApplyRequestsToFilters(action.filters, category.daffClearFilters(state.categoryPageMetadata.filters)) }) });
-            case DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction:
+            case exports.DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { filters: category.daffApplyRequestsToFilters(action.filters, state.categoryPageMetadata.filters) }) });
-            case DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction:
+            case exports.DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { filters: category.daffClearFilters(state.categoryPageMetadata.filters) }) });
-            case DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction:
+            case exports.DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { filters: category.daffRemoveRequestsFromFilters(action.filters, state.categoryPageMetadata.filters) }) });
-            case DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction:
+            case exports.DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction:
                 return Object.assign(Object.assign({}, state), { productsLoading: true, daffState: "Mutating" /* Mutating */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { filters: category.daffToggleRequestOnFilters(action.filter, state.categoryPageMetadata.filters) }) });
-            case DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction:
                 return Object.assign(Object.assign({}, state), { categoryLoading: false, productsLoading: false, daffState: "Stable" /* Stable */, categoryPageMetadata: Object.assign(Object.assign({}, state.categoryPageMetadata), { id: action.response.categoryPageMetadata.id, current_page: action.response.categoryPageMetadata.current_page, page_size: action.response.categoryPageMetadata.page_size, filters: action.response.categoryPageMetadata.filters, sort_options: action.response.categoryPageMetadata.sort_options, total_pages: action.response.categoryPageMetadata.total_pages, total_products: action.response.categoryPageMetadata.total_products, product_ids: action.response.categoryPageMetadata.product_ids, applied_sort_option: state.categoryPageMetadata.applied_sort_option || action.response.categoryPageMetadata.sort_options.default }) });
-            case DaffCategoryPageActionTypes.CategoryPageLoadFailureAction:
+            case exports.DaffCategoryPageActionTypes.CategoryPageLoadFailureAction:
                 return Object.assign(Object.assign({}, state), { categoryLoading: false, productsLoading: false, errors: [action.errorMessage], daffState: "Stable" /* Stable */ });
             default:
                 return state;
         }
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: reducers/category-reducers.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * All daffodil defined category reducers.
-     * @type {?}
      */
     var daffCategoryReducers = {
         category: daffCategoryReducer,
         categoryEntities: daffCategoryEntitiesReducer,
     };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: reducers/category-store-feature-key.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * The key for the slice of category related redux state in the global redux state object.
-     * @type {?}
      */
     var DAFF_CATEGORY_STORE_FEATURE_KEY = 'daffCategory';
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: reducers/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: selectors/category-feature.selector.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * An interface for the entire category feature state.
-     * @record
-     * @template V
-     */
-    function DaffCategoryFeatureMemoizedSelectors() { }
-    if (false) {
-        /** @type {?} */
-        DaffCategoryFeatureMemoizedSelectors.prototype.selectCategoryFeatureState;
-    }
-    var ɵ0 = /**
-     * @return {?}
-     */ function () {
-        /** @type {?} */
+    var ɵ0 = function () {
         var cache;
-        return ( /**
-         * @template V
-         * @return {?}
-         */function () { return cache = cache
+        return function () { return cache = cache
             ? cache
-            : { selectCategoryFeatureState: i1.createFeatureSelector(DAFF_CATEGORY_STORE_FEATURE_KEY) }; });
+            : { selectCategoryFeatureState: i1.createFeatureSelector(DAFF_CATEGORY_STORE_FEATURE_KEY) }; };
     };
     /**
      * A function that returns a selector for the entire category feature state.
-     * @type {?}
      */
-    var getDaffCategoryFeatureSelector = ((ɵ0))();
+    var getDaffCategoryFeatureSelector = (ɵ0)();
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: selectors/category-entities/category-entities.selector.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * An interface to describe all selectors related to category ngrx entities state.
-     * @record
-     * @template V
-     */
-    function DaffCategoryEntitiesMemoizedSelectors() { }
-    if (false) {
-        /**
-         * Selects ngrx category entities state.
-         * @type {?}
-         */
-        DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryEntitiesState;
-        /**
-         * Selects the ids of all categories in state.
-         * @type {?}
-         */
-        DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryIds;
-        /**
-         * Selects all categories in state as a dictionary.
-         * @type {?}
-         */
-        DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryEntities;
-        /**
-         * Selects all categories in state as an array.
-         * @type {?}
-         */
-        DaffCategoryEntitiesMemoizedSelectors.prototype.selectAllCategories;
-        /**
-         * Selects the total number of categories in state.
-         * @type {?}
-         */
-        DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryTotal;
-    }
-    /** @type {?} */
-    var createCategoryFeatureSelectors = ( /**
-     * @template V
-     * @return {?}
-     */function () {
-        /** @type {?} */
+    var createCategoryFeatureSelectors = function () {
         var entitiesSelectors = daffCategoryEntitiesAdapter().getSelectors();
-        /** @type {?} */
         var categoryFeatureState = getDaffCategoryFeatureSelector().selectCategoryFeatureState;
-        /** @type {?} */
-        var selectCategoryEntitiesState = i1.createSelector(categoryFeatureState, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.categoryEntities; }));
-        /** @type {?} */
+        var selectCategoryEntitiesState = i1.createSelector(categoryFeatureState, function (state) { return state.categoryEntities; });
         var selectCategoryIds = i1.createSelector(selectCategoryEntitiesState, entitiesSelectors.selectIds);
-        /** @type {?} */
         var selectCategoryEntities = i1.createSelector(selectCategoryEntitiesState, entitiesSelectors.selectEntities);
-        /** @type {?} */
         var selectAllCategories = i1.createSelector(selectCategoryEntitiesState, entitiesSelectors.selectAll);
-        /** @type {?} */
         var selectCategoryTotal = i1.createSelector(selectCategoryEntitiesState, entitiesSelectors.selectTotal);
         return {
             selectCategoryEntitiesState: selectCategoryEntitiesState,
@@ -644,247 +359,41 @@
             selectAllCategories: selectAllCategories,
             selectCategoryTotal: selectCategoryTotal,
         };
-    });
+    };
     var ɵ0$1 = createCategoryFeatureSelectors;
-    var ɵ1 = /**
-     * @return {?}
-     */ function () {
-        /** @type {?} */
+    var ɵ1 = function () {
         var cache;
-        return ( /**
-         * @template V
-         * @return {?}
-         */function () { return cache = cache
+        return function () { return cache = cache
             ? cache
-            : createCategoryFeatureSelectors(); });
+            : createCategoryFeatureSelectors(); };
     };
     /**
      * A function that returns all selectors related to category entities.
-     * @type {?}
      */
-    var getDaffCategoryEntitiesSelectors = ((ɵ1))();
+    var getDaffCategoryEntitiesSelectors = (ɵ1)();
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: selectors/category-page/category-page.selector.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * An interface to describe all selectors related to the category page metadata, category loading, and errors.
-     * @record
-     * @template V
-     */
-    function DaffCategoryPageMemoizedSelectors() { }
-    if (false) {
-        /**
-         * Selects all state related to the category page metadata, category loading, and errors.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryState;
-        /**
-         * Selects the metadata for the current category page.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageMetadata;
-        /**
-         * Selects the current page of products of the current category.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryCurrentPage;
-        /**
-         * Selects the total number of pages of products that exist in the current category.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryTotalPages;
-        /**
-         * Selects the number of products on each category page.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageSize;
-        /**
-         * Selects the filters that may be applied to the current category.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryFilters;
-        /**
-         * Selects the sort options that may be applied to the current category.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategorySortOptions;
-        /**
-         * Selects the ids of all products in the current category page.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageProductIds;
-        /**
-         * Selects whether the category page has no products.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectIsCategoryPageEmpty;
-        /**
-         * Selects the total number of products for the current category.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageTotalProducts;
-        /**
-         * Returns a dict of filters and only their applied options.
-         * Filters with no applied options will be omitted.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageAppliedFilters;
-        /**
-         * Selects the applied sorting option if one is applied.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageAppliedSortOption;
-        /**
-         * Selects the applied sorting direction if a sorting option is applied.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageAppliedSortDirection;
-        /**
-         * Selects the loading state of the current category; e.g. mutating, resolving, stable.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageState;
-        /**
-         * Selects the id of the current category.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCurrentCategoryId;
-        /**
-         * @deprecated Use selectIsCategoryPageResolving instead
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryLoading;
-        /**
-         * @deprecated Use selectIsCategoryPageResolving and selectIsCategoryPageMutating instead
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryProductsLoading;
-        /**
-         * Selects all errors associated with loading a category.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectCategoryErrors;
-        /**
-         * Selects whether the current category page is mutating; e.g. when a filter is applied to it.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectIsCategoryPageMutating;
-        /**
-         * Selects whether the current category is resolving; e.g. when the category first loads.
-         * @type {?}
-         */
-        DaffCategoryPageMemoizedSelectors.prototype.selectIsCategoryPageResolving;
-    }
-    /** @type {?} */
-    var createCategoryPageSelectors = ( /**
-     * @template V
-     * @return {?}
-     */function () {
-        /** @type {?} */
+    var createCategoryPageSelectors = function () {
         var selectCategoryFeatureState = getDaffCategoryFeatureSelector().selectCategoryFeatureState;
-        /** @type {?} */
-        var selectCategoryState = i1.createSelector(selectCategoryFeatureState, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.category; }));
-        /** @type {?} */
-        var selectCategoryPageMetadata = i1.createSelector(selectCategoryState, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.categoryPageMetadata; }));
-        /** @type {?} */
-        var selectCategoryCurrentPage = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.current_page; }));
-        /** @type {?} */
-        var selectCategoryTotalPages = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.total_pages; }));
-        /** @type {?} */
-        var selectCategoryPageSize = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.page_size; }));
-        /** @type {?} */
-        var selectCategoryFilters = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.filters; }));
-        /** @type {?} */
-        var selectCategorySortOptions = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.sort_options.options; }));
-        /** @type {?} */
-        var selectCategoryPageProductIds = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.product_ids; }));
-        /** @type {?} */
-        var selectIsCategoryPageEmpty = i1.createSelector(selectCategoryPageProductIds, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return !state.length; }));
-        /** @type {?} */
-        var selectCategoryPageTotalProducts = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.total_products; }));
-        /** @type {?} */
-        var selectCategoryPageAppliedFilters = i1.createSelector(selectCategoryFilters, ( /**
-         * @param {?} filters
-         * @return {?}
-         */function (filters) { return category.daffCategoryComputeAppliedFilters(filters); }));
-        /** @type {?} */
-        var selectCategoryPageAppliedSortOption = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.applied_sort_option; }));
-        /** @type {?} */
-        var selectCategoryPageAppliedSortDirection = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.applied_sort_direction; }));
-        /** @type {?} */
-        var selectCategoryPageState = i1.createSelector(selectCategoryState, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.daffState; }));
-        /** @type {?} */
-        var selectCurrentCategoryId = i1.createSelector(selectCategoryPageMetadata, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.id; }));
-        /** @type {?} */
-        var selectCategoryLoading = i1.createSelector(selectCategoryState, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.categoryLoading; }));
-        /** @type {?} */
-        var selectCategoryProductsLoading = i1.createSelector(selectCategoryState, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.productsLoading; }));
-        /** @type {?} */
-        var selectCategoryErrors = i1.createSelector(selectCategoryState, ( /**
-         * @param {?} state
-         * @return {?}
-         */function (state) { return state.errors; }));
-        /** @type {?} */
-        var selectIsCategoryPageMutating = i1.createSelector(selectCategoryPageState, ( /**
-         * @param {?} daffState
-         * @return {?}
-         */function (daffState) { return daffState === "Mutating"; } /* Mutating */));
-        /** @type {?} */
-        var selectIsCategoryPageResolving = i1.createSelector(selectCategoryPageState, ( /**
-         * @param {?} daffState
-         * @return {?}
-         */function (daffState) { return daffState === "Resolving"; } /* Resolving */));
+        var selectCategoryState = i1.createSelector(selectCategoryFeatureState, function (state) { return state.category; });
+        var selectCategoryPageMetadata = i1.createSelector(selectCategoryState, function (state) { return state.categoryPageMetadata; });
+        var selectCategoryCurrentPage = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.current_page; });
+        var selectCategoryTotalPages = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.total_pages; });
+        var selectCategoryPageSize = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.page_size; });
+        var selectCategoryFilters = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.filters; });
+        var selectCategorySortOptions = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.sort_options.options; });
+        var selectCategoryPageProductIds = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.product_ids; });
+        var selectIsCategoryPageEmpty = i1.createSelector(selectCategoryPageProductIds, function (state) { return !state.length; });
+        var selectCategoryPageTotalProducts = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.total_products; });
+        var selectCategoryPageAppliedFilters = i1.createSelector(selectCategoryFilters, function (filters) { return category.daffCategoryComputeAppliedFilters(filters); });
+        var selectCategoryPageAppliedSortOption = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.applied_sort_option; });
+        var selectCategoryPageAppliedSortDirection = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.applied_sort_direction; });
+        var selectCategoryPageState = i1.createSelector(selectCategoryState, function (state) { return state.daffState; });
+        var selectCurrentCategoryId = i1.createSelector(selectCategoryPageMetadata, function (state) { return state.id; });
+        var selectCategoryLoading = i1.createSelector(selectCategoryState, function (state) { return state.categoryLoading; });
+        var selectCategoryProductsLoading = i1.createSelector(selectCategoryState, function (state) { return state.productsLoading; });
+        var selectCategoryErrors = i1.createSelector(selectCategoryState, function (state) { return state.errors; });
+        var selectIsCategoryPageMutating = i1.createSelector(selectCategoryPageState, function (daffState) { return daffState === "Mutating"; } /* Mutating */);
+        var selectIsCategoryPageResolving = i1.createSelector(selectCategoryPageState, function (daffState) { return daffState === "Resolving"; } /* Resolving */);
         return {
             selectCategoryState: selectCategoryState,
             selectCategoryPageMetadata: selectCategoryPageMetadata,
@@ -907,179 +416,58 @@
             selectIsCategoryPageMutating: selectIsCategoryPageMutating,
             selectIsCategoryPageResolving: selectIsCategoryPageResolving,
         };
-    });
+    };
     var ɵ0$2 = createCategoryPageSelectors;
-    var ɵ1$1 = /**
-     * @return {?}
-     */ function () {
-        /** @type {?} */
+    var ɵ1$1 = function () {
         var cache;
-        return ( /**
-         * @template V
-         * @return {?}
-         */function () { return cache = cache
+        return function () { return cache = cache
             ? cache
-            : createCategoryPageSelectors(); });
+            : createCategoryPageSelectors(); };
     };
     /**
      * A function that returns all selectors related to the category page metadata, category loading, and errors.
-     * Returns {\@link DaffCategoryPageMemoizedSelectors}.
-     * @type {?}
+     * Returns {@link DaffCategoryPageMemoizedSelectors}.
      */
-    var getDaffCategoryPageSelectors = ((ɵ1$1))();
+    var getDaffCategoryPageSelectors = (ɵ1$1)();
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: selectors/category.selector.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * An interface for selectors that combine category metadata and category entities selectors.
-     * @record
-     * @template V, W
-     */
-    function DaffCategoryMemoizedSelectors() { }
-    if (false) {
-        /**
-         * Selects the current category
-         * @type {?}
-         */
-        DaffCategoryMemoizedSelectors.prototype.selectCurrentCategory;
-        /**
-         * Selects the products of the current category.
-         * @type {?}
-         */
-        DaffCategoryMemoizedSelectors.prototype.selectCategoryPageProducts;
-        /**
-         * Selects a category by id.
-         *
-         * \@param categoryId a category id.
-         * @type {?}
-         */
-        DaffCategoryMemoizedSelectors.prototype.selectCategory;
-        /**
-         * Selects products by category id.
-         *
-         * \@param categoryId a category id.
-         * @type {?}
-         */
-        DaffCategoryMemoizedSelectors.prototype.selectProductsByCategory;
-        /**
-         * Selects the total number of products in a category.
-         *
-         * \@param categoryId a category id.
-         * @type {?}
-         */
-        DaffCategoryMemoizedSelectors.prototype.selectTotalProductsByCategory;
-    }
-    /** @type {?} */
-    var createCategorySelectors = ( /**
-     * @template V, W
-     * @return {?}
-     */function () {
+    var createCategorySelectors = function () {
         var _a = state.getDaffProductSelectors(), selectAllProducts = _a.selectAllProducts, selectProductEntities = _a.selectProductEntities;
         var selectCategoryEntities = getDaffCategoryEntitiesSelectors().selectCategoryEntities;
         var _b = getDaffCategoryPageSelectors(), selectCurrentCategoryId = _b.selectCurrentCategoryId, selectCategoryPageProductIds = _b.selectCategoryPageProductIds;
         /**
          * Combinatoric Category Selectors
-         * @type {?}
          */
-        var selectCurrentCategory = i1.createSelector(selectCategoryEntities, selectCurrentCategoryId, ( /**
-         * @param {?} entities
-         * @param {?} currentCategoryId
-         * @return {?}
-         */function (entities, currentCategoryId) { return entities[currentCategoryId]; }));
-        /** @type {?} */
-        var selectCategoryPageProducts = i1.createSelector(selectCategoryPageProductIds, selectProductEntities, ( /**
-         * @param {?} ids
-         * @param {?} products
-         * @return {?}
-         */function (ids, products) { return ids.map(( /**
-         * @param {?} id
-         * @return {?}
-         */function (/**
-         * @param {?} id
-         * @return {?}
-         */ id) { return products[id]; })).filter(( /**
-         * @param {?} p
-         * @return {?}
-         */function (/**
-         * @param {?} p
-         * @return {?}
-         */ p) { return p != null; })); }));
-        /** @type {?} */
-        var selectCategory = i1.defaultMemoize(( /**
-         * @param {?} categoryId
-         * @return {?}
-         */function (categoryId) { return i1.createSelector(selectCategoryEntities, ( /**
-         * @param {?} entities
-         * @return {?}
-         */function (entities) { return entities[categoryId]; })); })).memoized;
-        /** @type {?} */
-        var selectProductsByCategory = i1.defaultMemoize(( /**
-         * @param {?} categoryId
-         * @return {?}
-         */function (categoryId) { return i1.createSelector(selectCategory(categoryId), selectAllProducts, ( /**
-         * @param {?} category
-         * @param {?} products
-         * @return {?}
-         */function (category, products) { return (category === null || category === void 0 ? void 0 : category.product_ids) ? products.filter(( /**
-         * @param {?} product
-         * @return {?}
-         */function (/**
-         * @param {?} product
-         * @return {?}
-         */ product) { return category.product_ids.indexOf(product.id) >= 0; }))
-            : []; })); })).memoized;
-        /** @type {?} */
-        var selectTotalProductsByCategory = i1.defaultMemoize(( /**
-         * @param {?} categoryId
-         * @return {?}
-         */function (categoryId) { return i1.createSelector(selectProductsByCategory(categoryId), ( /**
-         * @param {?} products
-         * @return {?}
-         */function (products) { return products.length; })); })).memoized;
+        var selectCurrentCategory = i1.createSelector(selectCategoryEntities, selectCurrentCategoryId, function (entities, currentCategoryId) { return entities[currentCategoryId]; });
+        var selectCategoryPageProducts = i1.createSelector(selectCategoryPageProductIds, selectProductEntities, function (ids, products) { return ids.map(function (id) { return products[id]; }).filter(function (p) { return p != null; }); });
+        var selectCategory = i1.defaultMemoize(function (categoryId) { return i1.createSelector(selectCategoryEntities, function (entities) { return entities[categoryId]; }); }).memoized;
+        var selectProductsByCategory = i1.defaultMemoize(function (categoryId) { return i1.createSelector(selectCategory(categoryId), selectAllProducts, function (category, products) { return (category === null || category === void 0 ? void 0 : category.product_ids) ? products.filter(function (product) { return category.product_ids.indexOf(product.id) >= 0; })
+            : []; }); }).memoized;
+        var selectTotalProductsByCategory = i1.defaultMemoize(function (categoryId) { return i1.createSelector(selectProductsByCategory(categoryId), function (products) { return products.length; }); }).memoized;
         return Object.assign(Object.assign(Object.assign(Object.assign({}, getDaffCategoryFeatureSelector()), getDaffCategoryEntitiesSelectors()), getDaffCategoryPageSelectors()), { selectCurrentCategory: selectCurrentCategory,
             selectCategoryPageProducts: selectCategoryPageProducts,
             selectCategory: selectCategory,
             selectProductsByCategory: selectProductsByCategory,
             selectTotalProductsByCategory: selectTotalProductsByCategory });
-    });
+    };
     var ɵ0$3 = createCategorySelectors;
-    var ɵ1$2 = /**
-     * @return {?}
-     */ function () {
-        /** @type {?} */
+    var ɵ1$2 = function () {
         var cache;
-        return ( /**
-         * @template V, W
-         * @return {?}
-         */function () { return cache = cache
+        return function () { return cache = cache
             ? cache
-            : createCategorySelectors(); });
+            : createCategorySelectors(); };
     };
     /**
      * A function that returns all combinatoric category selectors.
-     * @type {?}
      */
-    var getDaffCategorySelectors = ((ɵ1$2))();
+    var getDaffCategorySelectors = (ɵ1$2)();
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: facades/category.facade.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * A facade for interacting with the category state.
      * This facade exposes many parts of the state for easy access and allows dispatching of actions.
      *
-     * \@inheritdoc
-     * @template V, W
+     * @inheritdoc
      */
     var DaffCategoryFacade = /** @class */ (function () {
-        /**
-         * @param {?} store
-         */
         function DaffCategoryFacade(store) {
             this.store = store;
             this.categorySelectors = getDaffCategorySelectors();
@@ -1103,38 +491,26 @@
             this.errors$ = this.store.pipe(i1.select(this.categorySelectors.selectCategoryErrors));
             this.isCategoryEmpty$ = this.store.pipe(i1.select(this.categorySelectors.selectIsCategoryPageEmpty));
         }
-        /**
-         * @param {?} id
-         * @return {?}
-         */
         DaffCategoryFacade.prototype.getCategoryById = function (id) {
             return this.store.pipe(i1.select(this.categorySelectors.selectCategory(id)));
         };
-        /**
-         * @param {?} categoryId
-         * @return {?}
-         */
         DaffCategoryFacade.prototype.getProductsByCategory = function (categoryId) {
             return this.store.pipe(i1.select(this.categorySelectors.selectProductsByCategory(categoryId)));
         };
-        /**
-         * @param {?} categoryId
-         * @return {?}
-         */
         DaffCategoryFacade.prototype.getTotalProductsByCategory = function (categoryId) {
             return this.store.pipe(i1.select(this.categorySelectors.selectTotalProductsByCategory(categoryId)));
         };
         /**
          * Dispatches the given action.
          *
-         * @param {?} action action to dispatch.
-         * @return {?}
+         * @param action action to dispatch.
          */
         DaffCategoryFacade.prototype.dispatch = function (action) {
             this.store.dispatch(action);
         };
         return DaffCategoryFacade;
     }());
+    /** @nocollapse */ DaffCategoryFacade.ɵprov = i0.ɵɵdefineInjectable({ factory: function DaffCategoryFacade_Factory() { return new DaffCategoryFacade(i0.ɵɵinject(i1.Store)); }, token: DaffCategoryFacade, providedIn: "root" });
     DaffCategoryFacade.decorators = [
         { type: i0.Injectable, args: [{
                     providedIn: 'root',
@@ -1144,57 +520,6 @@
     DaffCategoryFacade.ctorParameters = function () { return [
         { type: i1.Store }
     ]; };
-    /** @nocollapse */ DaffCategoryFacade.ɵprov = i0.ɵɵdefineInjectable({ factory: function DaffCategoryFacade_Factory() { return new DaffCategoryFacade(i0.ɵɵinject(i1.Store)); }, token: DaffCategoryFacade, providedIn: "root" });
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryFacade.prototype.categorySelectors;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.category$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.metadata$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.pageLoadingState$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.isPageMutating$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.isPageResolving$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.currentPage$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.totalPages$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.totalProducts$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.pageSize$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.filters$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.sortOptions$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.appliedFilters$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.appliedSortOption$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.appliedSortDirection$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.products$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.categoryLoading$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.productsLoading$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.errors$;
-        /** @type {?} */
-        DaffCategoryFacade.prototype.isCategoryEmpty$;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryFacade.prototype.store;
-    }
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -1431,7 +756,7 @@
                     ar[i] = from[i];
                 }
             }
-        return to.concat(ar || from);
+        return to.concat(ar || Array.prototype.slice.call(from));
     }
     function __await(v) {
         return this instanceof __await ? (this.v = v, this) : new __await(v);
@@ -1514,16 +839,7 @@
         return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
     }
 
-    /**
-     * @template V, W
-     */
     var DaffCategoryPageFilterEffects = /** @class */ (function () {
-        /**
-         * @param {?} actions$
-         * @param {?} driver
-         * @param {?} errorMatcher
-         * @param {?} facade
-         */
         function DaffCategoryPageFilterEffects(actions$, driver, errorMatcher, facade) {
             var _this = this;
             this.actions$ = actions$;
@@ -1538,17 +854,10 @@
              * @param throttleWindow the amount of time to delay when apply/removing filters
              * in a sequence.
              */
-            this.updateFilters$ = ( /**
-             * @param {?=} throttleWindow
-             * @param {?=} scheduler
-             * @return {?}
-             */function (throttleWindow, scheduler) {
+            this.updateFilters$ = function (throttleWindow, scheduler) {
                 if (throttleWindow === void 0) { throttleWindow = 300; }
                 if (scheduler === void 0) { scheduler = rxjs.asyncScheduler; }
-                return _this.actions$.pipe(effects.ofType(DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction), operators.withLatestFrom(_this.facade.metadata$), operators.map(( /**
-                 * @param {?} __0
-                 * @return {?}
-                 */function (_a) {
+                return _this.actions$.pipe(effects.ofType(exports.DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction, exports.DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction, exports.DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction, exports.DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction, exports.DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction, exports.DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction), operators.withLatestFrom(_this.facade.metadata$), operators.map(function (_a) {
                     var _b = __read(_a, 2), action = _b[0], metadata = _b[1];
                     return ({
                         kind: category.DaffCategoryRequestKind.ID,
@@ -1559,23 +868,11 @@
                         current_page: metadata.current_page,
                         page_size: metadata.page_size,
                     });
-                })), operators.throttleTime(throttleWindow, scheduler, { leading: true, trailing: true }), operators.switchMap(( /**
-                 * @param {?} payload
-                 * @return {?}
-                 */function (/**
-                 * @param {?} payload
-                 * @return {?}
-                 */ payload) { return _this.driver.get(payload).pipe(operators.switchMap(( /**
-                 * @param {?} resp
-                 * @return {?}
-                 */function (resp) { return [
+                }), operators.throttleTime(throttleWindow, scheduler, { leading: true, trailing: true }), operators.switchMap(function (payload) { return _this.driver.get(payload).pipe(operators.switchMap(function (resp) { return [
                     new state.DaffProductGridLoadSuccess(resp.products),
                     new DaffCategoryPageLoadSuccess(resp),
-                ]; })), operators.catchError(( /**
-                 * @param {?} error
-                 * @return {?}
-                 */function (error) { return rxjs.of(new DaffCategoryPageLoadFailure(_this.errorMatcher(error))); }))); })));
-            });
+                ]; }), operators.catchError(function (error) { return rxjs.of(new DaffCategoryPageLoadFailure(_this.errorMatcher(error))); })); }));
+            };
         }
         return DaffCategoryPageFilterEffects;
     }());
@@ -1593,49 +890,8 @@
         effects.Effect(),
         __metadata("design:type", Function)
     ], DaffCategoryPageFilterEffects.prototype, "updateFilters$", void 0);
-    if (false) {
-        /**
-         * Updates the filters applied to the category page. It will take the currently
-         * applied filters from state, form them into a request, and attempt to apply
-         * that request to a backend service.
-         *
-         * \@param throttleWindow the amount of time to delay when apply/removing filters
-         * in a sequence.
-         * @type {?}
-         */
-        DaffCategoryPageFilterEffects.prototype.updateFilters$;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageFilterEffects.prototype.actions$;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageFilterEffects.prototype.driver;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageFilterEffects.prototype.errorMatcher;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageFilterEffects.prototype.facade;
-    }
 
-    /**
-     * @template V, W
-     */
     var DaffCategoryPageEffects = /** @class */ (function () {
-        /**
-         * @param {?} actions$
-         * @param {?} driver
-         * @param {?} errorMatcher
-         * @param {?} store
-         */
         function DaffCategoryPageEffects(actions$, driver, errorMatcher, store) {
             var _this = this;
             this.actions$ = actions$;
@@ -1643,62 +899,30 @@
             this.errorMatcher = errorMatcher;
             this.store = store;
             this.categorySelectors = getDaffCategorySelectors();
-            this.loadCategoryPage$ = this.actions$.pipe(effects.ofType(DaffCategoryPageActionTypes.CategoryPageLoadAction), operators.switchMap(( /**
-             * @param {?} action
-             * @return {?}
-             */function (action) { return _this.processCategoryGetRequest(action.request); })));
-            this.loadCategoryPageByUrl$ = this.actions$.pipe(effects.ofType(DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction), operators.switchMap(( /**
-             * @param {?} action
-             * @return {?}
-             */function (action) { return _this.driver.getByUrl(action.request).pipe(operators.switchMap(( /**
-             * @param {?} resp
-             * @return {?}
-             */function (resp) { return [
+            this.loadCategoryPage$ = this.actions$.pipe(effects.ofType(exports.DaffCategoryPageActionTypes.CategoryPageLoadAction), operators.switchMap(function (action) { return _this.processCategoryGetRequest(action.request); }));
+            this.loadCategoryPageByUrl$ = this.actions$.pipe(effects.ofType(exports.DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction), operators.switchMap(function (action) { return _this.driver.getByUrl(action.request).pipe(operators.switchMap(function (resp) { return [
                 new state.DaffProductGridLoadSuccess(resp.products),
                 new DaffCategoryPageLoadSuccess(resp),
-            ]; })), operators.catchError(( /**
-             * @param {?} error
-             * @return {?}
-             */function (error) { return rxjs.of(new DaffCategoryPageLoadFailure(_this.errorMatcher(error))); }))); })));
-            this.changeCategoryPageSize$ = this.actions$.pipe(effects.ofType(DaffCategoryPageActionTypes.CategoryPageChangeSizeAction), operators.withLatestFrom(this.store.pipe(i1.select(this.categorySelectors.selectCategoryPageMetadata))), operators.switchMap(( /**
-             * @param {?} __0
-             * @return {?}
-             */function (_a) {
+            ]; }), operators.catchError(function (error) { return rxjs.of(new DaffCategoryPageLoadFailure(_this.errorMatcher(error))); })); }));
+            this.changeCategoryPageSize$ = this.actions$.pipe(effects.ofType(exports.DaffCategoryPageActionTypes.CategoryPageChangeSizeAction), operators.withLatestFrom(this.store.pipe(i1.select(this.categorySelectors.selectCategoryPageMetadata))), operators.switchMap(function (_a) {
                 var _b = __read(_a, 2), action = _b[0], metadata = _b[1];
                 return _this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: category.DaffCategoryRequestKind.ID, filter_requests: category.daffCategoryFiltersToRequests(metadata.filters), page_size: action.pageSize }));
-            })));
-            this.changeCategoryCurrentPage$ = this.actions$.pipe(effects.ofType(DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction), operators.withLatestFrom(this.store.pipe(i1.select(this.categorySelectors.selectCategoryPageMetadata))), operators.switchMap(( /**
-             * @param {?} __0
-             * @return {?}
-             */function (_a) {
+            }));
+            this.changeCategoryCurrentPage$ = this.actions$.pipe(effects.ofType(exports.DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction), operators.withLatestFrom(this.store.pipe(i1.select(this.categorySelectors.selectCategoryPageMetadata))), operators.switchMap(function (_a) {
                 var _b = __read(_a, 2), action = _b[0], metadata = _b[1];
                 return _this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: category.DaffCategoryRequestKind.ID, filter_requests: category.daffCategoryFiltersToRequests(metadata.filters), current_page: action.currentPage }));
-            })));
-            this.changeCategorySort$ = this.actions$.pipe(effects.ofType(DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction), operators.withLatestFrom(this.store.pipe(i1.select(this.categorySelectors.selectCategoryPageMetadata))), operators.switchMap(( /**
-             * @param {?} __0
-             * @return {?}
-             */function (_a) {
+            }));
+            this.changeCategorySort$ = this.actions$.pipe(effects.ofType(exports.DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction), operators.withLatestFrom(this.store.pipe(i1.select(this.categorySelectors.selectCategoryPageMetadata))), operators.switchMap(function (_a) {
                 var _b = __read(_a, 2), action = _b[0], metadata = _b[1];
                 return _this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: category.DaffCategoryRequestKind.ID, filter_requests: category.daffCategoryFiltersToRequests(metadata.filters), applied_sort_option: action.sort.option, applied_sort_direction: action.sort.direction }));
-            })));
+            }));
         }
-        /**
-         * @private
-         * @param {?} payload
-         * @return {?}
-         */
         DaffCategoryPageEffects.prototype.processCategoryGetRequest = function (payload) {
             var _this = this;
-            return this.driver.get(payload).pipe(operators.switchMap(( /**
-             * @param {?} resp
-             * @return {?}
-             */function (resp) { return [
+            return this.driver.get(payload).pipe(operators.switchMap(function (resp) { return [
                 new state.DaffProductGridLoadSuccess(resp.products),
                 new DaffCategoryPageLoadSuccess(resp),
-            ]; })), operators.catchError(( /**
-             * @param {?} error
-             * @return {?}
-             */function (error) { return rxjs.of(new DaffCategoryPageLoadFailure(_this.errorMatcher(error))); })));
+            ]; }), operators.catchError(function (error) { return rxjs.of(new DaffCategoryPageLoadFailure(_this.errorMatcher(error))); }));
         };
         return DaffCategoryPageEffects;
     }());
@@ -1732,73 +956,14 @@
         effects.Effect(),
         __metadata("design:type", rxjs.Observable)
     ], DaffCategoryPageEffects.prototype, "changeCategorySort$", void 0);
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageEffects.prototype.categorySelectors;
-        /** @type {?} */
-        DaffCategoryPageEffects.prototype.loadCategoryPage$;
-        /** @type {?} */
-        DaffCategoryPageEffects.prototype.loadCategoryPageByUrl$;
-        /** @type {?} */
-        DaffCategoryPageEffects.prototype.changeCategoryPageSize$;
-        /** @type {?} */
-        DaffCategoryPageEffects.prototype.changeCategoryCurrentPage$;
-        /** @type {?} */
-        DaffCategoryPageEffects.prototype.changeCategorySort$;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageEffects.prototype.actions$;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageEffects.prototype.driver;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageEffects.prototype.errorMatcher;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryPageEffects.prototype.store;
-    }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: effects/category.effects.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template V, W
-     */
     var DaffCategoryEffects = /** @class */ (function () {
-        /**
-         * @param {?} actions$
-         * @param {?} driver
-         * @param {?} errorMatcher
-         */
         function DaffCategoryEffects(actions$, driver, errorMatcher) {
             var _this = this;
             this.actions$ = actions$;
             this.driver = driver;
             this.errorMatcher = errorMatcher;
-            this.loadCategory$ = this.actions$.pipe(effects.ofType(DaffCategoryActionTypes.CategoryLoadAction), operators.mergeMap(( /**
-             * @param {?} action
-             * @return {?}
-             */function (action) { return _this.driver.get(action.request).pipe(operators.switchMap(( /**
-             * @param {?} resp
-             * @return {?}
-             */function (resp) { return rxjs.of(new state.DaffProductGridLoadSuccess(resp.products), new DaffCategoryLoadSuccess(resp)); })), operators.catchError(( /**
-             * @param {?} error
-             * @return {?}
-             */function (error) { return rxjs.of(new DaffCategoryLoadFailure(_this.errorMatcher(error))); }))); })));
+            this.loadCategory$ = this.actions$.pipe(effects.ofType(exports.DaffCategoryActionTypes.CategoryLoadAction), operators.mergeMap(function (action) { return _this.driver.get(action.request).pipe(operators.switchMap(function (resp) { return rxjs.of(new state.DaffProductGridLoadSuccess(resp.products), new DaffCategoryLoadSuccess(resp)); }), operators.catchError(function (error) { return rxjs.of(new DaffCategoryLoadFailure(_this.errorMatcher(error))); })); }));
         }
         return DaffCategoryEffects;
     }());
@@ -1815,31 +980,7 @@
         effects.Effect(),
         __metadata("design:type", rxjs.Observable)
     ], DaffCategoryEffects.prototype, "loadCategory$", void 0);
-    if (false) {
-        /** @type {?} */
-        DaffCategoryEffects.prototype.loadCategory$;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryEffects.prototype.actions$;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryEffects.prototype.driver;
-        /**
-         * @type {?}
-         * @private
-         */
-        DaffCategoryEffects.prototype.errorMatcher;
-    }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: category-state.module.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * A module that provides default reducers and effects for the category redux state.
      */
@@ -1859,37 +1000,20 @@
     ];
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: index.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: daffodil-category-state.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Generated bundle index. Do not edit.
      */
 
     exports.DAFF_CATEGORY_STORE_FEATURE_KEY = DAFF_CATEGORY_STORE_FEATURE_KEY;
-    exports.DaffCategoryActionTypes = DaffCategoryActionTypes;
     exports.DaffCategoryFacade = DaffCategoryFacade;
     exports.DaffCategoryLoad = DaffCategoryLoad;
     exports.DaffCategoryLoadFailure = DaffCategoryLoadFailure;
     exports.DaffCategoryLoadSuccess = DaffCategoryLoadSuccess;
-    exports.DaffCategoryPageActionTypes = DaffCategoryPageActionTypes;
     exports.DaffCategoryPageApplyFilters = DaffCategoryPageApplyFilters;
     exports.DaffCategoryPageChangeCurrentPage = DaffCategoryPageChangeCurrentPage;
     exports.DaffCategoryPageChangeFilters = DaffCategoryPageChangeFilters;
     exports.DaffCategoryPageChangePageSize = DaffCategoryPageChangePageSize;
     exports.DaffCategoryPageChangeSortingOption = DaffCategoryPageChangeSortingOption;
     exports.DaffCategoryPageClearFilters = DaffCategoryPageClearFilters;
-    exports.DaffCategoryPageFilterActionTypes = DaffCategoryPageFilterActionTypes;
     exports.DaffCategoryPageLoad = DaffCategoryPageLoad;
     exports.DaffCategoryPageLoadByUrl = DaffCategoryPageLoadByUrl;
     exports.DaffCategoryPageLoadFailure = DaffCategoryPageLoadFailure;
@@ -1902,6 +1026,8 @@
     exports.daffCategoryReducer = daffCategoryReducer;
     exports.daffCategoryReducers = daffCategoryReducers;
     exports.getDaffCategorySelectors = getDaffCategorySelectors;
+    exports.ɵ0 = ɵ0$3;
+    exports.ɵ1 = ɵ1$2;
     exports.ɵa = DaffCategoryEffects;
     exports.ɵb = DaffCategoryPageEffects;
     exports.ɵc = DaffCategoryPageFilterEffects;