@daffodil/category 0.38.9 → 0.39.0

package/bundles/daffodil-category.umd.js

@@ -5,139 +5,48 @@
 }(this, (function (exports, core, core$1, state) { 'use strict';
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: models/filters/type/category-filter-type.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * The known types of filters.
      */
-    /** @enum {string} */
-    var DaffCategoryFilterType = {
-        Equal: "equal",
-        RangeNumeric: "rangeNumeric",
-    };
+    (function (DaffCategoryFilterType) {
+        DaffCategoryFilterType["Equal"] = "equal";
+        DaffCategoryFilterType["RangeNumeric"] = "rangeNumeric";
+    })(exports.DaffCategoryFilterType || (exports.DaffCategoryFilterType = {}));
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: models/filters/type/range/separator.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * The separator between a range type filter's values
      * e.g. "price": "30-40".
-     * @type {?}
      */
     var DaffCategoryFromToFilterSeparator = '-';
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: models/filters/type/range/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: models/filters/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * When you request a category page, there's two ways to do so, via URL or via ID.
      */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: models/category-request.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @enum {string} */
-    var DaffCategoryRequestKind = {
-        URL: "URL",
+    (function (DaffCategoryRequestKind) {
+        DaffCategoryRequestKind["URL"] = "URL";
         // eslint-disable-next-line @typescript-eslint/no-shadow
-        ID: "ID",
-    };
-    /**
-     * A model of the request sent to the {\@link DaffCategoryServiceInterface} to retrieve information
-     * about a category.
-     * @record
-     */
-    function DaffCategoryBaseRequest() { }
-    if (false) {
-        /**
-         * The properties by which to filter the items of the category being requested.
-         * @type {?|undefined}
-         */
-        DaffCategoryBaseRequest.prototype.filter_requests;
-        /**
-         * The option by which to sort a category's items.
-         * @type {?|undefined}
-         */
-        DaffCategoryBaseRequest.prototype.applied_sort_option;
-        /**
-         * The direction by which to sort the category's items.
-         * @type {?|undefined}
-         */
-        DaffCategoryBaseRequest.prototype.applied_sort_direction;
-        /**
-         * What page of the category's items to retrieve.
-         * @type {?|undefined}
-         */
-        DaffCategoryBaseRequest.prototype.current_page;
-        /**
-         * The number of items per-page to request.
-         * @type {?|undefined}
-         */
-        DaffCategoryBaseRequest.prototype.page_size;
-    }
-    /**
-     * A request used to retrieve a category by its uid.
-     * @record
-     */
-    function DaffCategoryIdRequest() { }
-    if (false) {
-        /** @type {?} */
-        DaffCategoryIdRequest.prototype.id;
-        /** @type {?} */
-        DaffCategoryIdRequest.prototype.kind;
-    }
-    /**
-     * A request used to retrieve a category by its URL.
-     * The qualified URL without domain.
-     * e.g. a/path/to/the/category.html
-     * @record
-     */
-    function DaffCategoryUrlRequest() { }
-    if (false) {
-        /** @type {?} */
-        DaffCategoryUrlRequest.prototype.kind;
-    }
+        DaffCategoryRequestKind["ID"] = "ID";
+    })(exports.DaffCategoryRequestKind || (exports.DaffCategoryRequestKind = {}));
     ;
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: models/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/errors/codes.enum.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * The error codes applicable to the filter behaviors of `@daffodil/category`.
+     *
+     * @docs-private
      */
-    /** @enum {string} */
-    var DaffCategoryFilterErrorCodes = {
-        FILTER_REQUEST_TYPE_MISMATCH: "DAFF_CATEGORY_FILTER_REQUEST_TYPE_MISMATCH",
-        FILTER_REQUEST_NAME_MISMATCH: "DAFF_CATEGORY_FILTER_REQUEST_NAME_MISMATCH",
-        FILTER_NOT_FOUND: "DAFF_CATEGORY_FILTER_NOT_FOUND",
-        UNKNOWN_FILTER_TYPE: "DAFF_CATEGORY_UNKNOWN_FILTER_TYPE",
-    };
+    var DaffCategoryFilterErrorCodes;
+    (function (DaffCategoryFilterErrorCodes) {
+        DaffCategoryFilterErrorCodes["FILTER_REQUEST_TYPE_MISMATCH"] = "DAFF_CATEGORY_FILTER_REQUEST_TYPE_MISMATCH";
+        DaffCategoryFilterErrorCodes["FILTER_REQUEST_NAME_MISMATCH"] = "DAFF_CATEGORY_FILTER_REQUEST_NAME_MISMATCH";
+        DaffCategoryFilterErrorCodes["FILTER_NOT_FOUND"] = "DAFF_CATEGORY_FILTER_NOT_FOUND";
+        DaffCategoryFilterErrorCodes["UNKNOWN_FILTER_TYPE"] = "DAFF_CATEGORY_UNKNOWN_FILTER_TYPE";
+    })(DaffCategoryFilterErrorCodes || (DaffCategoryFilterErrorCodes = {}));
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: errors/codes.enum.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      *
-     * The available error codes of the \@daffodil/category package.
+     * The available error codes of the @daffodil/category package.
      *
-     * Note that this only contains errors in the root \@daffodil/category package, not
-     * any of its subpackages e.g. `\@daffodil/category/testing`.
-     * @type {?}
+     * Note that this only contains errors in the root @daffodil/category package, not
+     * any of its subpackages e.g. `@daffodil/category/testing`.
      */
     var DaffCategoryErrorCodes = Object.assign({}, DaffCategoryFilterErrorCodes);
 
@@ -376,7 +285,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);
@@ -464,9 +373,6 @@
      */
     var DaffCategoryFilterNotFound = /** @class */ (function (_super) {
         __extends(DaffCategoryFilterNotFound, _super);
-        /**
-         * @param {?=} message
-         */
         function DaffCategoryFilterNotFound(message) {
             var _this = _super.call(this, message) || this;
             _this.code = DaffCategoryErrorCodes.FILTER_NOT_FOUND;
@@ -474,10 +380,6 @@
         }
         return DaffCategoryFilterNotFound;
     }(core.DaffInheritableError));
-    if (false) {
-        /** @type {?} */
-        DaffCategoryFilterNotFound.prototype.code;
-    }
 
     /**
      * An error thrown when an operation targeting a filter matching one name
@@ -485,9 +387,6 @@
      */
     var DaffCategoryFilterRequestNameMismatch = /** @class */ (function (_super) {
         __extends(DaffCategoryFilterRequestNameMismatch, _super);
-        /**
-         * @param {?=} message
-         */
         function DaffCategoryFilterRequestNameMismatch(message) {
             var _this = _super.call(this, message) || this;
             _this.code = DaffCategoryErrorCodes.FILTER_REQUEST_NAME_MISMATCH;
@@ -495,10 +394,6 @@
         }
         return DaffCategoryFilterRequestNameMismatch;
     }(core.DaffInheritableError));
-    if (false) {
-        /** @type {?} */
-        DaffCategoryFilterRequestNameMismatch.prototype.code;
-    }
 
     /**
      * An error thrown when an operation targeting a filter matching one type
@@ -506,9 +401,6 @@
      */
     var DaffCategoryFilterRequestTypeMismatch = /** @class */ (function (_super) {
         __extends(DaffCategoryFilterRequestTypeMismatch, _super);
-        /**
-         * @param {?=} message
-         */
         function DaffCategoryFilterRequestTypeMismatch(message) {
             var _this = _super.call(this, message) || this;
             _this.code = DaffCategoryErrorCodes.FILTER_REQUEST_TYPE_MISMATCH;
@@ -516,10 +408,6 @@
         }
         return DaffCategoryFilterRequestTypeMismatch;
     }(core.DaffInheritableError));
-    if (false) {
-        /** @type {?} */
-        DaffCategoryFilterRequestTypeMismatch.prototype.code;
-    }
 
     /**
      * An error thrown when an operation targeting a filter matches a type unknown
@@ -527,9 +415,6 @@
      */
     var DaffCategoryUnknownFilterType = /** @class */ (function (_super) {
         __extends(DaffCategoryUnknownFilterType, _super);
-        /**
-         * @param {?=} message
-         */
         function DaffCategoryUnknownFilterType(message) {
             var _this = _super.call(this, message) || this;
             _this.code = DaffCategoryErrorCodes.UNKNOWN_FILTER_TYPE;
@@ -537,15 +422,10 @@
         }
         return DaffCategoryUnknownFilterType;
     }(core.DaffInheritableError));
-    if (false) {
-        /** @type {?} */
-        DaffCategoryUnknownFilterType.prototype.code;
-    }
 
     var _a;
     /**
      * A mapping from error codes to error class constructors.
-     * @type {?}
      */
     var DaffCategoryFiltersErrorMap = (_a = {},
         _a[DaffCategoryFilterErrorCodes.FILTER_REQUEST_TYPE_MISMATCH] = DaffCategoryFilterRequestTypeMismatch,
@@ -554,102 +434,40 @@
         _a[DaffCategoryFilterErrorCodes.UNKNOWN_FILTER_TYPE] = DaffCategoryUnknownFilterType,
         _a);
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: errors/map.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * A mapping from error codes to error class constructors.
-     * @type {?}
      */
     var DaffCategoryErrorMap = Object.assign({}, DaffCategoryFiltersErrorMap);
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: errors/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: injection-tokens/error-matcher.token.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Transforms `DaffError`s into `DaffStateError`s before they are serialized into state.
      * Can be used to further refine Daffodil errors into more specific app errors.
-     * @type {?}
-     */
-    var DAFF_CATEGORY_ERROR_MATCHER = new core$1.InjectionToken('DAFF_CATEGORY_ERROR_MATCHER', { factory: ( /**
-             * @return {?}
-             */function () { return state.daffTransformErrorToStateError; }) });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: injection-tokens/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
+    var DAFF_CATEGORY_ERROR_MATCHER = new core$1.InjectionToken('DAFF_CATEGORY_ERROR_MATCHER', { factory: function () { return state.daffTransformErrorToStateError; } });
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/behaviors/apply/apply.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Applies a {\@link DaffCategoryFilterEqualRequest} to a {\@link DaffCategoryFilterEqual}
+     * Applies a {@link DaffCategoryFilterEqualRequest} to a {@link DaffCategoryFilterEqual}
      *
-     * \@idempotent {filter}
-     * \@docs-private
-     * @type {?}
+     * @idempotent {filter}
+     * @docs-private
      */
-    var daffApplyFilterEqual = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) { return (Object.assign(Object.assign({}, filter), { options: request.value.reduce(( /**
-             * @param {?} acc
-             * @param {?} value
-             * @return {?}
-             */function (acc, value) {
-            /** @type {?} */
+    var daffApplyFilterEqual = function (request, filter) { return (Object.assign(Object.assign({}, filter), { options: request.value.reduce(function (acc, value) {
             var option = filter.options[value];
             if (option) {
                 acc[value] = Object.assign(Object.assign({}, option), { applied: true });
             }
             return acc;
-        }), Object.assign({}, filter.options)) })); });
+        }, Object.assign({}, filter.options)) })); };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/compute-pair-label.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
-    var daffCategoryComputeFilterRangePairLabel = ( /**
-     * @param {?} min
-     * @param {?} max
-     * @return {?}
-     */function (min, max) { return "" + min + DaffCategoryFromToFilterSeparator + max; });
+    var daffCategoryComputeFilterRangePairLabel = function (min, max) { return "" + min + DaffCategoryFromToFilterSeparator + max; };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/behaviors/apply/apply.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Applies a {\@link DaffCategoryFilterRangeRequestBase} to a {\@link DaffCategoryFilterRangeBase}
+     * Applies a {@link DaffCategoryFilterRangeRequestBase} to a {@link DaffCategoryFilterRangeBase}
      *
-     * \@idempotent {filter}
-     * \@docs-private
-     * @type {?}
+     * @idempotent {filter}
+     * @docs-private
      */
-    var daffApplyFilterRange = ( /**
-     * @template T, U, V
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) {
+    var daffApplyFilterRange = function (request, filter) {
         var _a;
         return (Object.assign(Object.assign({}, filter), { options: (_a = {},
                 _a[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)] = {
@@ -664,677 +482,319 @@
                     applied: true,
                 },
                 _a) }));
-    });
+    };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/validators/request-name-match.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Ensures that the names of the filter and the filter request match.
      *
-     * @throws {\@link DaffCategoryFilterNotFound} if the names do not match.
-     * @type {?}
+     * @throws {@link DaffCategoryFilterNotFound} if the names do not match.
      */
-    var daffCategoryValidateFilterRequestNameMatch = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) {
+    var daffCategoryValidateFilterRequestNameMatch = function (request, filter) {
         if (!filter) {
             throw new DaffCategoryFilterNotFound('Filter does not exist');
         }
         if (request.name !== filter.name) {
             throw new DaffCategoryFilterRequestNameMismatch('Filter name does not match request name');
         }
-    });
+    };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/validators/request-type-match.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Ensures that the types of the filter and the filter request match.
      *
-     * @throws {\@link DaffCategoryFilterRequestTypeMismatch} if the types do not match.
-     * @type {?}
+     * @throws {@link DaffCategoryFilterRequestTypeMismatch} if the types do not match.
      */
-    var daffCategoryValidateFilterRequestTypeMatch = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) {
+    var daffCategoryValidateFilterRequestTypeMatch = function (request, filter) {
         if (request.type !== filter.type) {
             throw new DaffCategoryFilterRequestTypeMismatch('Filter types don\'t match');
         }
-    });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/validators/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
+    };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/apply/apply-filter.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Applies a filter request to the matching filter.
      *
-     * \@idempotent {filter}
-     * @throws {\@link DaffCategoryUnknownFilterType}
-     * @type {?}
+     * @idempotent {filter}
+     * @throws {@link DaffCategoryUnknownFilterType}
      */
-    var daffApplyFilter = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) {
+    var daffApplyFilter = function (request, filter) {
         daffCategoryValidateFilterRequestNameMatch(request, filter);
         daffCategoryValidateFilterRequestTypeMatch(request, filter);
         switch (request.type) {
-            case DaffCategoryFilterType.Equal:
-                return daffApplyFilterEqual(request, ( /** @type {?} */(filter)));
-            case (DaffCategoryFilterType.RangeNumeric):
-                return daffApplyFilterRange(request, ( /** @type {?} */(filter)));
+            case exports.DaffCategoryFilterType.Equal:
+                return daffApplyFilterEqual(request, filter);
+            case (exports.DaffCategoryFilterType.RangeNumeric):
+                return daffApplyFilterRange(request, filter);
             default:
                 throw new DaffCategoryUnknownFilterType('Unknown filter type');
         }
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/apply/apply-request-to-filters.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Applies a {\@link DaffCategoryFilterRequest} to a {\@link Dict} of {\@link DaffCategoryFilter}
-     * returning the updated {\@link Dict}.
+     * Applies a {@link DaffCategoryFilterRequest} to a {@link Dict} of {@link DaffCategoryFilter}
+     * returning the updated {@link Dict}.
      *
-     * \@idempotent {filters}
-     * @type {?}
+     * @idempotent {filters}
      */
-    var daffApplyRequestToFilters = ( /**
-     * @param {?} request
-     * @param {?} filters
-     * @return {?}
-     */function (request, filters) {
+    var daffApplyRequestToFilters = function (request, filters) {
         var _a;
         return (Object.assign(Object.assign({}, filters), (_a = {}, _a[request.name] = daffApplyFilter(request, filters[request.name]), _a)));
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/apply/apply-requests-to-filters.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Applies filters from a {\@link DaffCategoryFilterRequest} to a {\@link Dict}
-     * of {\@link DaffCategoryFilter}.
+     * Applies filters from a {@link DaffCategoryFilterRequest} to a {@link Dict}
+     * of {@link DaffCategoryFilter}.
      *
-     * \@idempotent {filters}
-     * @type {?}
+     * @idempotent {filters}
      */
-    var daffApplyRequestsToFilters = ( /**
-     * @param {?} filtersRequests
-     * @param {?} filters
-     * @return {?}
-     */function (filtersRequests, filters) { return filtersRequests.reduce(( /**
-     * @param {?} acc
-     * @param {?} request
-     * @return {?}
-     */function (acc, request) {
+    var daffApplyRequestsToFilters = function (filtersRequests, filters) { return filtersRequests.reduce(function (acc, request) {
         acc[request.name] = daffApplyFilter(request, filters[request.name]);
         return acc;
-    }), Object.assign({}, filters)); });
+    }, Object.assign({}, filters)); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/apply/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/behaviors/clear/clear.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Unapplies the applied filter options of a {\@link DaffCategoryFilterEqual}
+     * Unapplies the applied filter options of a {@link DaffCategoryFilterEqual}
      *
-     * \@idempotent {filter}
-     * \@docs-private
-     * @type {?}
+     * @idempotent {filter}
+     * @docs-private
      */
-    var daffClearFilterEqual = ( /**
-     * @param {?} filter
-     * @return {?}
-     */function (filter) { return (Object.assign(Object.assign({}, filter), { options: Object.keys(filter.options).map(( /**
-             * @param {?} key
-             * @return {?}
-             */function (key) { return filter.options[key]; })).reduce(( /**
-         * @param {?} acc
-         * @param {?} option
-         * @return {?}
-         */function (acc, option) {
+    var daffClearFilterEqual = function (filter) { return (Object.assign(Object.assign({}, filter), { options: Object.keys(filter.options).map(function (key) { return filter.options[key]; }).reduce(function (acc, option) {
             acc[option.value] = Object.assign(Object.assign({}, option), { applied: false });
             return acc;
-        }), Object.assign({}, filter.options)) })); });
+        }, Object.assign({}, filter.options)) })); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/behaviors/clear/clear.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Unapplies the applied filter options of a {\@link DaffCategoryFilterRangeBase}
+     * Unapplies the applied filter options of a {@link DaffCategoryFilterRangeBase}
      *
-     * \@idempotent {filter}
-     * \@docs-private
-     * @type {?}
+     * @idempotent {filter}
+     * @docs-private
      */
-    var daffClearFilterRange = ( /**
-     * @template T, U
-     * @param {?} filter
-     * @return {?}
-     */function (filter) { return (Object.assign(Object.assign({}, filter), { options: {} })); });
+    var daffClearFilterRange = function (filter) { return (Object.assign(Object.assign({}, filter), { options: {} })); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/clear/clear-filter.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Undoes the applied state of all applied filter options of a {\@link DaffCategoryFilter}
+     * Undoes the applied state of all applied filter options of a {@link DaffCategoryFilter}
      * returning the filter.
      *
-     * \@idempotent {filter}
-     * @type {?}
+     * @idempotent {filter}
      */
-    var daffClearFilter = ( /**
-     * @param {?} filter
-     * @return {?}
-     */function (filter) {
+    var daffClearFilter = function (filter) {
         switch (filter.type) {
-            case DaffCategoryFilterType.RangeNumeric:
+            case exports.DaffCategoryFilterType.RangeNumeric:
                 return daffClearFilterRange(filter);
-            case DaffCategoryFilterType.Equal:
+            case exports.DaffCategoryFilterType.Equal:
                 return daffClearFilterEqual(filter);
             default:
                 throw new DaffCategoryUnknownFilterType('Unknown filter type');
         }
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/clear/clear-filters.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Undoes the applied state of all applied filter options of a {\@link Dict} of {\@link DaffCategoryFilter}
-     * returning updated {\@link Dict}.
+     * Undoes the applied state of all applied filter options of a {@link Dict} of {@link DaffCategoryFilter}
+     * returning updated {@link Dict}.
      *
-     * \@idempotent {filters}
-     * @type {?}
+     * @idempotent {filters}
      */
-    var daffClearFilters = ( /**
-     * @param {?} filters
-     * @return {?}
-     */function (filters) { return Object.keys(filters).map(( /**
-     * @param {?} key
-     * @return {?}
-     */function (key) { return filters[key]; })).reduce(( /**
-     * @param {?} acc
-     * @param {?} filter
-     * @return {?}
-     */function (acc, filter) {
+    var daffClearFilters = function (filters) { return Object.keys(filters).map(function (key) { return filters[key]; }).reduce(function (acc, filter) {
         acc[filter.name] = daffClearFilter(filter);
         return acc;
-    }), {}); });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/clear/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
+    }, {}); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/behaviors/remove/remove.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Removes the matching filter options of a {\@link DaffCategoryFilterEqual}
-     * that match the {\@link DaffCategoryFilterEqualRequest}
+     * Removes the matching filter options of a {@link DaffCategoryFilterEqual}
+     * that match the {@link DaffCategoryFilterEqualRequest}
      *
-     * If there are no matching options, returns the original {\@link DaffCategoryFilterEqual}
+     * If there are no matching options, returns the original {@link DaffCategoryFilterEqual}
      *
-     * \@idempotent {filter}
-     * \@docs-private
-     * @type {?}
+     * @idempotent {filter}
+     * @docs-private
      */
-    var daffRemoveFilterEqual = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) { return (Object.assign(Object.assign({}, filter), { options: request.value.reduce(( /**
-             * @param {?} acc
-             * @param {?} value
-             * @return {?}
-             */function (acc, value) {
-            /** @type {?} */
+    var daffRemoveFilterEqual = function (request, filter) { return (Object.assign(Object.assign({}, filter), { options: request.value.reduce(function (acc, value) {
             var option = filter.options[value];
             if (option) {
                 acc[value] = Object.assign(Object.assign({}, option), { applied: false });
             }
             return acc;
-        }), Object.assign({}, filter.options)) })); });
+        }, Object.assign({}, filter.options)) })); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/behaviors/remove/remove.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Removes the matching filter options of a {\@link DaffCategoryFilterRangeBase}
-     * that match the {\@link DaffCategoryFilterRangeRequestBase}
+     * Removes the matching filter options of a {@link DaffCategoryFilterRangeBase}
+     * that match the {@link DaffCategoryFilterRangeRequestBase}
      *
-     * If there are no matching options, returns the original {\@link DaffCategoryFilterRangeBase}
+     * If there are no matching options, returns the original {@link DaffCategoryFilterRangeBase}
      *
-     * \@idempotent {filter}
-     * \@docs-private
-     * @type {?}
+     * @idempotent {filter}
+     * @docs-private
      */
-    var daffRemoveFilterRange = ( /**
-     * @template T, U
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) { return filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
+    var daffRemoveFilterRange = function (request, filter) { return filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
         ? (Object.assign(Object.assign({}, filter), { options: {} }))
-        : filter; });
+        : filter; };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/remove/remove-filter.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Undoes any applied options of a {\@link DaffCategoryFilter} that match the
-     * {\@link DaffCategoryFilterRequest}, returning the {\@link DaffCategoryFilter}.
+     * Undoes any applied options of a {@link DaffCategoryFilter} that match the
+     * {@link DaffCategoryFilterRequest}, returning the {@link DaffCategoryFilter}.
      *
-     * \@idempotent {filter}
-     * \@pure
-     * @type {?}
+     * @idempotent {filter}
+     * @pure
      */
-    var daffRemoveFilter = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) {
+    var daffRemoveFilter = function (request, filter) {
         daffCategoryValidateFilterRequestNameMatch(request, filter);
         daffCategoryValidateFilterRequestTypeMatch(request, filter);
         switch (request.type) {
-            case DaffCategoryFilterType.Equal:
-                return daffRemoveFilterEqual(request, ( /** @type {?} */(filter)));
-            case (DaffCategoryFilterType.RangeNumeric):
-                return daffRemoveFilterRange(request, ( /** @type {?} */(filter)));
+            case exports.DaffCategoryFilterType.Equal:
+                return daffRemoveFilterEqual(request, filter);
+            case (exports.DaffCategoryFilterType.RangeNumeric):
+                return daffRemoveFilterRange(request, filter);
             default:
                 throw new DaffCategoryUnknownFilterType('Unknown filter type');
         }
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/remove/remove-request-from-filters.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Undoes any applied options of a particular filter of a {\@link Dict} of {\@link DaffCategoryFilter}
-     * that match the {\@link DaffCategoryFilterRequest}, returning the {\@link Dict} of {\@link DaffCategoryFilter}.
+     * Undoes any applied options of a particular filter of a {@link Dict} of {@link DaffCategoryFilter}
+     * that match the {@link DaffCategoryFilterRequest}, returning the {@link Dict} of {@link DaffCategoryFilter}.
      *
-     * \@idempotent {filters}
-     * @type {?}
+     * @idempotent {filters}
      */
-    var daffRemoveRequestFromFilters = ( /**
-     * @param {?} request
-     * @param {?} filters
-     * @return {?}
-     */function (request, filters) {
+    var daffRemoveRequestFromFilters = function (request, filters) {
         var _a;
         return (Object.assign(Object.assign({}, filters), (_a = {}, _a[request.name] = daffRemoveFilter(request, filters[request.name]), _a)));
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/remove/remove-requests-from-filters.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Undoes all applied options of a {\@link Dict} of {\@link DaffCategoryFilter}
-     * that match any of the {\@link DaffCategoryFilterRequest},
-     * returning the updated {\@link Dict} of {\@link DaffCategoryFilter}.
+     * Undoes all applied options of a {@link Dict} of {@link DaffCategoryFilter}
+     * that match any of the {@link DaffCategoryFilterRequest},
+     * returning the updated {@link Dict} of {@link DaffCategoryFilter}.
      *
-     * \@idempotent {filters}
-     * @type {?}
+     * @idempotent {filters}
      */
-    var daffRemoveRequestsFromFilters = ( /**
-     * @param {?} requests
-     * @param {?} filters
-     * @return {?}
-     */function (requests, filters) { return requests.reduce(( /**
-     * @param {?} acc
-     * @param {?} request
-     * @return {?}
-     */function (acc, request) {
+    var daffRemoveRequestsFromFilters = function (requests, filters) { return requests.reduce(function (acc, request) {
         acc[request.name] = daffRemoveFilter(request, filters[request.name]);
         return acc;
-    }), Object.assign({}, filters)); });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/remove/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
+    }, Object.assign({}, filters)); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/behaviors/toggle/toggle.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Oscillates the applied state of the matching filter options of a {\@link DaffCategoryFilterEqual}
-     * that match the {\@link DaffCategoryFilterEqualRequest}
+     * Oscillates the applied state of the matching filter options of a {@link DaffCategoryFilterEqual}
+     * that match the {@link DaffCategoryFilterEqualRequest}
      *
-     * If there are no matching options, returns the original {\@link DaffCategoryFilterEqual}
+     * If there are no matching options, returns the original {@link DaffCategoryFilterEqual}
      *
-     * \@docs-private
-     * @type {?}
+     * @docs-private
      */
-    var daffToggleFilterEqual = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) {
+    var daffToggleFilterEqual = function (request, filter) {
         var _a;
-        /** @type {?} */
         var option = filter.options[request.value];
         return option
             ? Object.assign(Object.assign({}, filter), { options: Object.assign(Object.assign({}, filter.options), (_a = {}, _a[option.value] = Object.assign(Object.assign({}, option), { applied: !option.applied }), _a)) }) : filter;
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/behaviors/toggle/toggle.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Oscillates the applied state of the matching filter options of a {\@link DaffCategoryFilterRangeBase}
-     * that match the {\@link DaffCategoryFilterRangeRequestBase}
+     * Oscillates the applied state of the matching filter options of a {@link DaffCategoryFilterRangeBase}
+     * that match the {@link DaffCategoryFilterRangeRequestBase}
      *
-     * If there are no matching options, returns the original {\@link DaffCategoryFilterRangeBase}
+     * If there are no matching options, returns the original {@link DaffCategoryFilterRangeBase}
      *
-     * \@docs-private
-     * @type {?}
+     * @docs-private
      */
-    var daffToggleFilterRange = ( /**
-     * @template T, U
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) { return filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
+    var daffToggleFilterRange = function (request, filter) { return filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
         ? daffRemoveFilterRange(request, filter)
-        : daffApplyFilterRange(request, filter); });
+        : daffApplyFilterRange(request, filter); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/toggle/toggle.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Toggles the state of the filters (and their options) in the {\@link DaffCategoryFilter}
-     * that match the {\@link DaffCategoryFilterToggleRequest} .
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
+     * Toggles the state of the filters (and their options) in the {@link DaffCategoryFilter}
+     * that match the {@link DaffCategoryFilterToggleRequest} .
      */
     function daffToggleFilter(request, filter) {
         daffCategoryValidateFilterRequestNameMatch(request, filter);
         daffCategoryValidateFilterRequestTypeMatch(request, filter);
         switch (request.type) {
-            case DaffCategoryFilterType.Equal:
-                return daffToggleFilterEqual(request, ( /** @type {?} */(filter)));
-            case (DaffCategoryFilterType.RangeNumeric):
-                return daffToggleFilterRange(request, ( /** @type {?} */(filter)));
+            case exports.DaffCategoryFilterType.Equal:
+                return daffToggleFilterEqual(request, filter);
+            case (exports.DaffCategoryFilterType.RangeNumeric):
+                return daffToggleFilterRange(request, filter);
             default:
                 throw new DaffCategoryUnknownFilterType('Unknown filter type');
         }
     }
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/toggle/toggle-request-on-filters.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Toggles the state of a filter option in the {@link Dict<DaffCategoryFilter>}
+     * that matches the {@link DaffCategoryFilterToggleRequest}.
      */
-    /**
-     * Toggles the state of a filter option in the {\@link Dict<DaffCategoryFilter>}
-     * that matches the {\@link DaffCategoryFilterToggleRequest}.
-     * @type {?}
-     */
-    var daffToggleRequestOnFilters = ( /**
-     * @param {?} request
-     * @param {?} filters
-     * @return {?}
-     */function (request, filters) {
+    var daffToggleRequestOnFilters = function (request, filters) {
         var _a;
         return (Object.assign(Object.assign({}, filters), (_a = {}, _a[request.name] = daffToggleFilter(request, filters[request.name]), _a)));
-    });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/behaviors/toggle/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/is-applied/is-applied.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Determines whether or not the {\@link DaffCategoryFilterEqual} has any applied options.
-     * @type {?}
+     * Determines whether or not the {@link DaffCategoryFilterEqual} has any applied options.
      */
-    var daffIsFilterEqualApplied = ( /**
-     * @param {?} filter
-     * @return {?}
-     */function (filter) { return Object.keys(filter.options).map(( /**
-     * @param {?} key
-     * @return {?}
-     */function (key) { return filter.options[key]; })).findIndex(( /**
-     * @param {?} option
-     * @return {?}
-     */function (/**
-     * @param {?} option
-     * @return {?}
-     */ option) { return option.applied; })) > -1; });
+    var daffIsFilterEqualApplied = function (filter) { return Object.keys(filter.options).map(function (key) { return filter.options[key]; }).findIndex(function (option) { return option.applied; }) > -1; };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/is-applied/is-applied.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Determines whether or not a {\@link DaffCategoryFilterRangeBase} has any applied options.
-     * @type {?}
+     * Determines whether or not a {@link DaffCategoryFilterRangeBase} has any applied options.
      */
-    var daffIsFilterRangeApplied = ( /**
-     * @template T
-     * @param {?} filter
-     * @return {?}
-     */function (filter) { return Object.keys(filter.options).length > 0; });
+    var daffIsFilterRangeApplied = function (filter) { return Object.keys(filter.options).length > 0; };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/is-applied/is-filter-applied.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Determines whether or not a filter has any currently applied options.
-     * @type {?}
      */
-    var daffIsFilterApplied = ( /**
-     * @param {?} filter
-     * @return {?}
-     */function (filter) {
+    var daffIsFilterApplied = function (filter) {
         switch (filter.type) {
-            case DaffCategoryFilterType.RangeNumeric:
+            case exports.DaffCategoryFilterType.RangeNumeric:
                 return daffIsFilterRangeApplied(filter);
-            case DaffCategoryFilterType.Equal:
+            case exports.DaffCategoryFilterType.Equal:
                 return daffIsFilterEqualApplied(filter);
             default:
                 throw new DaffCategoryUnknownFilterType('Unknown filter type');
         }
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/is-applied/is-toggle-request-applied-to-filter.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Determines whether or not any {\@link DaffCategoryFilterEqual} options matching {\@link DaffCategoryFilterEqualToggleRequest} are applied.
-     * @type {?}
+     * Determines whether or not any {@link DaffCategoryFilterEqual} options matching {@link DaffCategoryFilterEqualToggleRequest} are applied.
      */
-    var daffIsEqualToggleRequestAppliedToFilter = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) { var _a; return !!((_a = filter.options[request.value]) === null || _a === void 0 ? void 0 : _a.applied); });
+    var daffIsEqualToggleRequestAppliedToFilter = function (request, filter) { var _a; return !!((_a = filter.options[request.value]) === null || _a === void 0 ? void 0 : _a.applied); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/is-applied/is-toggle-request-applied-to-filter.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Determines whether or not any {@link DaffCategoryFilterRangeBase} options matching {@link DaffCategoryFilterRangeRequestBase} are applied.
      */
-    /**
-     * Determines whether or not any {\@link DaffCategoryFilterRangeBase} options matching {\@link DaffCategoryFilterRangeRequestBase} are applied.
-     * @type {?}
-     */
-    var daffIsRangeToggleRequestAppliedToFilter = ( /**
-     * @template T
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) { return daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max) in filter.options; });
+    var daffIsRangeToggleRequestAppliedToFilter = function (request, filter) { return daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max) in filter.options; };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/is-applied/is-toggle-request-applied-to-filter.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Determines whether or not a {\@link DaffCategoryFilterToggleRequest} is already applied to a {\@link DaffCategoryFilter}.
-     * @type {?}
+     * Determines whether or not a {@link DaffCategoryFilterToggleRequest} is already applied to a {@link DaffCategoryFilter}.
      */
-    var daffIsToggleRequestAppliedToFilter = ( /**
-     * @param {?} request
-     * @param {?} filter
-     * @return {?}
-     */function (request, filter) {
+    var daffIsToggleRequestAppliedToFilter = function (request, filter) {
         switch (filter.type) {
-            case DaffCategoryFilterType.RangeNumeric:
-                return daffIsRangeToggleRequestAppliedToFilter(( /** @type {?} */(request)), filter);
-            case DaffCategoryFilterType.Equal:
-                return daffIsEqualToggleRequestAppliedToFilter(( /** @type {?} */(request)), filter);
+            case exports.DaffCategoryFilterType.RangeNumeric:
+                return daffIsRangeToggleRequestAppliedToFilter(request, filter);
+            case exports.DaffCategoryFilterType.Equal:
+                return daffIsEqualToggleRequestAppliedToFilter(request, filter);
             default:
                 throw new DaffCategoryUnknownFilterType('Unknown filter type');
         }
-    });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/is-applied/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
+    };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/find-applied/find-applied-options.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Finds the applied options in the filter.
-     * @type {?}
      */
-    var daffCategoryFindAppliedFilterOptions = ( /**
-     * @template T
-     * @param {?} filter
-     * @return {?}
-     */function (filter) { return Object.keys(filter.options).map(( /**
-     * @param {?} key
-     * @return {?}
-     */function (key) { return ( /** @type {?} */(filter.options[key])); })).filter(( /**
-     * @param {?} option
-     * @return {?}
-     */function (option) { return option.applied; })); });
+    var daffCategoryFindAppliedFilterOptions = function (filter) { return Object.keys(filter.options).map(function (key) { return filter.options[key]; }).filter(function (option) { return option.applied; }); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/find-applied/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Builds an {@link DaffCategoryFilterEqualRequest} from the passed filter and options.
      */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/to-request/filter-to-request.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Builds an {\@link DaffCategoryFilterEqualRequest} from the passed filter and options.
-     * @type {?}
-     */
-    var daffCategoryFilterEqualToRequest = ( /**
-     * @param {?} filter
-     * @return {?}
-     */function (filter) {
-        /** @type {?} */
+    var daffCategoryFilterEqualToRequest = function (filter) {
         var options = daffCategoryFindAppliedFilterOptions(filter);
         if (!options.length) {
             return null;
         }
         return {
-            type: DaffCategoryFilterType.Equal,
+            type: exports.DaffCategoryFilterType.Equal,
             name: filter.name,
-            value: options.map(( /**
-             * @param {?} option
-             * @return {?}
-             */function (/**
-             * @param {?} option
-             * @return {?}
-             */ option) { return option.value; })),
+            value: options.map(function (option) { return option.value; }),
         };
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/to-request/filter-to-request.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Builds a {\@link DaffCategoryFilterRangeRequestBase} from the passed {\@link DaffCategoryFilterRangeBase} and options.
-     * @type {?}
+     * Builds a {@link DaffCategoryFilterRangeRequestBase} from the passed {@link DaffCategoryFilterRangeBase} and options.
      */
-    var daffCategoryFilterRangeToRequest = ( /**
-     * @template T, U
-     * @param {?} filter
-     * @return {?}
-     */function (filter) {
-        /** @type {?} */
+    var daffCategoryFilterRangeToRequest = function (filter) {
         var options = daffCategoryFindAppliedFilterOptions(filter);
         if (!options.length) {
             return null;
@@ -1347,38 +807,22 @@
                 max: options[0].max.value,
             },
         };
-    });
+    };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range-numeric/to-request/filter-to-request.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Transforms a {@link DaffCategoryFilterRangeNumeric} into a {@link DaffCategoryFilterRangeNumericRequest}
      */
-    /**
-     * Transforms a {\@link DaffCategoryFilterRangeNumeric} into a {\@link DaffCategoryFilterRangeNumericRequest}
-     * @type {?}
-     */
-    var daffCategoryFilterRangeNumericToRequest = ( /**
-     * @param {?} filter
-     * @return {?}
-     */function (filter) { return ( /** @type {?} */(daffCategoryFilterRangeToRequest(filter))); });
+    var daffCategoryFilterRangeNumericToRequest = function (filter) { return daffCategoryFilterRangeToRequest(filter); };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/to-request/filter-to-request.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Builds a category filter request from a category filter.
      * Returns null if the category filter does not have at least one applied option.
-     * @param {?} filter
-     * @return {?}
      */
     function daffCategoryFilterToRequest(filter) {
         switch (filter.type) {
-            case DaffCategoryFilterType.RangeNumeric:
+            case exports.DaffCategoryFilterType.RangeNumeric:
                 return daffCategoryFilterRangeNumericToRequest(filter);
-            case DaffCategoryFilterType.Equal:
+            case exports.DaffCategoryFilterType.Equal:
                 return daffCategoryFilterEqualToRequest(filter);
             default:
                 throw new DaffCategoryUnknownFilterType('Unknown filter type');
@@ -1386,176 +830,51 @@
     }
     ;
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/to-request/filters-to-requests.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Builds a list of filter requests from a list of filters.
      * Requests are only built for the filters that have at least one applied option.
-     * @param {?} filters
-     * @return {?}
      */
     function daffCategoryFiltersToRequests(filters) {
-        return Object.keys(filters).map(( /**
-         * @param {?} key
-         * @return {?}
-         */function (key) { return filters[key]; })).reduce(( /**
-         * @param {?} acc
-         * @param {?} filter
-         * @return {?}
-         */function (acc, filter) {
-            /** @type {?} */
+        return Object.keys(filters).map(function (key) { return filters[key]; }).reduce(function (acc, filter) {
             var request = daffCategoryFilterToRequest(filter);
             if (request) {
                 acc.push(request);
             }
             return acc;
-        }), []);
+        }, []);
     }
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/to-request/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/array-to-dict/pair.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Transforms an {\@link DaffCategoryFilterRangePair[]} to a {\@link Dict<DaffCategoryFilterRangePair>}.
-     * @type {?}
-     */
-    var daffCategoryFilterRangePairArrayToDict = ( /**
-     * @template T
-     * @param {?} pairs
-     * @return {?}
-     */function (pairs) { return core.daffArrayToDict(pairs, ( /**
-     * @param {?} pair
-     * @return {?}
-     */function (/**
-     * @param {?} pair
-     * @return {?}
-     */ pair) { return daffCategoryComputeFilterRangePairLabel(pair.min.value, pair.max.value); })); });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/range/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Transforms an {@link DaffCategoryFilterRangePair[]} to a {@link Dict<DaffCategoryFilterRangePair>}.
      */
+    var daffCategoryFilterRangePairArrayToDict = function (pairs) { return core.daffArrayToDict(pairs, function (pair) { return daffCategoryComputeFilterRangePairLabel(pair.min.value, pair.max.value); }); };
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/array-to-dict/option.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     /**
      * Converts a list of category equal filter options to a dict of options keyed by option value.
-     * @type {?}
-     */
-    var daffCategoryFilterEqualOptionArrayToDict = ( /**
-     * @param {?} options
-     * @return {?}
-     */function (options) { return core.daffArrayToDict(options, ( /**
-     * @param {?} option
-     * @return {?}
-     */function (/**
-     * @param {?} option
-     * @return {?}
-     */ option) { return option.value; })); });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/type/equal/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/errors/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
+    var daffCategoryFilterEqualOptionArrayToDict = function (options) { return core.daffArrayToDict(options, function (option) { return option.value; }); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/array-to-dict/array-to-dict.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Converts a list of category filters into a {\@link Dict} of filters keyed by filter name.
-     * @type {?}
+     * Converts a list of category filters into a {@link Dict} of filters keyed by filter name.
      */
-    var daffCategoryFilterArrayToDict = ( /**
-     * @param {?} filters
-     * @return {?}
-     */function (filters) { return core.daffArrayToDict(filters, ( /**
-     * @param {?} filter
-     * @return {?}
-     */function (/**
-     * @param {?} filter
-     * @return {?}
-     */ filter) { return filter.name; })); });
+    var daffCategoryFilterArrayToDict = function (filters) { return core.daffArrayToDict(filters, function (filter) { return filter.name; }); };
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/compute-applied-filters/compute-applied-filters.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Returns a {@link Dict<DaffCategoryFilter>} and only their applied options.
+     * {@link DaffCategoryFilter} that have no applied options will be omitted.
      */
-    /**
-     * Returns a {\@link Dict<DaffCategoryFilter>} and only their applied options.
-     * {\@link DaffCategoryFilter} that have no applied options will be omitted.
-     * @type {?}
-     */
-    var daffCategoryComputeAppliedFilters = ( /**
-     * @param {?} filters
-     * @return {?}
-     */function (filters) { return Object.keys(filters).map(( /**
-     * @param {?} key
-     * @return {?}
-     */function (/**
-     * @param {?} key
-     * @return {?}
-     */ key) { return filters[key]; })).reduce(( /**
-     * @param {?} acc
-     * @param {?} filter
-     * @return {?}
-     */function (acc, filter) {
-        /** @type {?} */
+    var daffCategoryComputeAppliedFilters = function (filters) { return Object.keys(filters).map(function (key) { return filters[key]; }).reduce(function (acc, filter) {
         var appliedOptions = daffCategoryFindAppliedFilterOptions(filter);
         if (appliedOptions.length > 0) {
-            acc[filter.name] = Object.assign(Object.assign({}, filter), { options: filter.type === DaffCategoryFilterType.Equal
-                    ? daffCategoryFilterEqualOptionArrayToDict(( /** @type {?} */(appliedOptions)))
-                    : daffCategoryFilterRangePairArrayToDict(( /** @type {?} */(appliedOptions))) });
+            acc[filter.name] = Object.assign(Object.assign({}, filter), { options: filter.type === exports.DaffCategoryFilterType.Equal
+                    ? daffCategoryFilterEqualOptionArrayToDict(appliedOptions)
+                    : daffCategoryFilterRangePairArrayToDict(appliedOptions) });
         }
         return acc;
-    }), {}); });
-
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: filters/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-
-    /**
-     * @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.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Generated bundle index. Do not edit.
      */
 
     exports.DAFF_CATEGORY_ERROR_MATCHER = DAFF_CATEGORY_ERROR_MATCHER;
@@ -1564,9 +883,7 @@
     exports.DaffCategoryFilterNotFound = DaffCategoryFilterNotFound;
     exports.DaffCategoryFilterRequestNameMismatch = DaffCategoryFilterRequestNameMismatch;
     exports.DaffCategoryFilterRequestTypeMismatch = DaffCategoryFilterRequestTypeMismatch;
-    exports.DaffCategoryFilterType = DaffCategoryFilterType;
     exports.DaffCategoryFromToFilterSeparator = DaffCategoryFromToFilterSeparator;
-    exports.DaffCategoryRequestKind = DaffCategoryRequestKind;
     exports.DaffCategoryUnknownFilterType = DaffCategoryUnknownFilterType;
     exports.daffApplyFilter = daffApplyFilter;
     exports.daffApplyRequestToFilters = daffApplyRequestToFilters;