@daffodil/category 0.38.9 → 0.39.0

package/fesm2015/daffodil-category.js

@@ -3,253 +3,98 @@ import { InjectionToken } from '@angular/core';
 import { daffTransformErrorToStateError } from '@daffodil/core/state';
 
 /**
- * @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
- */
-/** @enum {string} */
-const DaffCategoryFilterType = {
-    Equal: "equal",
-    RangeNumeric: "rangeNumeric",
-};
-
-/**
- * @fileoverview added by tsickle
- * Generated from: models/filters/type/equal/public_api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * The known types of filters.
  */
+var DaffCategoryFilterType;
+(function (DaffCategoryFilterType) {
+    DaffCategoryFilterType["Equal"] = "equal";
+    DaffCategoryFilterType["RangeNumeric"] = "rangeNumeric";
+})(DaffCategoryFilterType || (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 {?}
  */
 const 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/type/range-numeric/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
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: models/category-request.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.
  */
-/** @enum {string} */
-const DaffCategoryRequestKind = {
-    URL: "URL",
+var DaffCategoryRequestKind;
+(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";
+})(DaffCategoryRequestKind || (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} */
-const 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`.
  */
 const DaffCategoryErrorCodes = Object.assign({}, DaffCategoryFilterErrorCodes);
 
-/**
- * @fileoverview added by tsickle
- * Generated from: filters/errors/filter-not-found.error.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * An error thrown when a lookup for a filter.
  */
 class DaffCategoryFilterNotFound extends DaffInheritableError {
-    /**
-     * @param {?=} message
-     */
     constructor(message) {
         super(message);
         this.code = DaffCategoryErrorCodes.FILTER_NOT_FOUND;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryFilterNotFound.prototype.code;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: filters/errors/request-name-mismatch.error.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * An error thrown when an operation targeting a filter matching one name
  * matches a filter of another name.
  */
 class DaffCategoryFilterRequestNameMismatch extends DaffInheritableError {
-    /**
-     * @param {?=} message
-     */
     constructor(message) {
         super(message);
         this.code = DaffCategoryErrorCodes.FILTER_REQUEST_NAME_MISMATCH;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryFilterRequestNameMismatch.prototype.code;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: filters/errors/request-type-mismatch.error.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * An error thrown when an operation targeting a filter matching one type
  * matches a filter of another type.
  */
 class DaffCategoryFilterRequestTypeMismatch extends DaffInheritableError {
-    /**
-     * @param {?=} message
-     */
     constructor(message) {
         super(message);
         this.code = DaffCategoryErrorCodes.FILTER_REQUEST_TYPE_MISMATCH;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryFilterRequestTypeMismatch.prototype.code;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: filters/errors/unknown-filter-type.error.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * An error thrown when an operation targeting a filter matches a type unknown
  * to Daffodil.
  */
 class DaffCategoryUnknownFilterType extends DaffInheritableError {
-    /**
-     * @param {?=} message
-     */
     constructor(message) {
         super(message);
         this.code = DaffCategoryErrorCodes.UNKNOWN_FILTER_TYPE;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryUnknownFilterType.prototype.code;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: filters/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 {?}
  */
 const DaffCategoryFiltersErrorMap = {
     [DaffCategoryFilterErrorCodes.FILTER_REQUEST_TYPE_MISMATCH]: DaffCategoryFilterRequestTypeMismatch,
@@ -258,107 +103,40 @@ const DaffCategoryFiltersErrorMap = {
     [DaffCategoryFilterErrorCodes.UNKNOWN_FILTER_TYPE]: DaffCategoryUnknownFilterType,
 };
 
-/**
- * @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 {?}
  */
 const 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 {?}
  */
-const DAFF_CATEGORY_ERROR_MATCHER = new InjectionToken('DAFF_CATEGORY_ERROR_MATCHER', { factory: (/**
-     * @return {?}
-     */
-    () => daffTransformErrorToStateError) });
+const DAFF_CATEGORY_ERROR_MATCHER = new InjectionToken('DAFF_CATEGORY_ERROR_MATCHER', { factory: () => daffTransformErrorToStateError });
 
 /**
- * @fileoverview added by tsickle
- * Generated from: injection-tokens/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/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
  */
-const daffApplyFilterEqual = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
- */
-(request, filter) => (Object.assign(Object.assign({}, filter), { options: request.value.reduce((/**
-     * @param {?} acc
-     * @param {?} value
-     * @return {?}
-     */
-    (acc, value) => {
-        /** @type {?} */
+const daffApplyFilterEqual = (request, filter) => (Object.assign(Object.assign({}, filter), { options: request.value.reduce((acc, value) => {
         const 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 {?} */
-const daffCategoryComputeFilterRangePairLabel = (/**
- * @param {?} min
- * @param {?} max
- * @return {?}
- */
-(min, max) => `${min}${DaffCategoryFromToFilterSeparator}${max}`);
+const daffCategoryComputeFilterRangePairLabel = (min, max) => `${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
  */
-const daffApplyFilterRange = (/**
- * @template T, U, V
- * @param {?} request
- * @param {?} filter
- * @return {?}
- */
-(request, filter) => (Object.assign(Object.assign({}, filter), { options: {
+const daffApplyFilterRange = (request, filter) => (Object.assign(Object.assign({}, filter), { options: {
         [daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]: {
             min: {
                 value: request.value.min,
@@ -370,209 +148,97 @@ const daffApplyFilterRange = (/**
             },
             applied: true,
         },
-    } })));
+    } }));
 
-/**
- * @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 {?}
- */
-const daffCategoryValidateFilterRequestNameMatch = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
+ * @throws {@link DaffCategoryFilterNotFound} if the names do not match.
  */
-(request, filter) => {
+const daffCategoryValidateFilterRequestNameMatch = (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 {?}
- */
-const daffCategoryValidateFilterRequestTypeMatch = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
+ * @throws {@link DaffCategoryFilterRequestTypeMismatch} if the types do not match.
  */
-(request, filter) => {
+const daffCategoryValidateFilterRequestTypeMatch = (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 {?}
- */
-const daffApplyFilter = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
+ * @idempotent {filter}
+ * @throws {@link DaffCategoryUnknownFilterType}
  */
-(request, filter) => {
+const daffApplyFilter = (request, filter) => {
     daffCategoryValidateFilterRequestNameMatch(request, filter);
     daffCategoryValidateFilterRequestTypeMatch(request, filter);
     switch (request.type) {
         case DaffCategoryFilterType.Equal:
-            return daffApplyFilterEqual(request, (/** @type {?} */ (filter)));
+            return daffApplyFilterEqual(request, filter);
         case (DaffCategoryFilterType.RangeNumeric):
-            return daffApplyFilterRange(request, (/** @type {?} */ (filter)));
+            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}
  */
-const daffApplyRequestToFilters = (/**
- * @param {?} request
- * @param {?} filters
- * @return {?}
- */
-(request, filters) => (Object.assign(Object.assign({}, filters), { [request.name]: daffApplyFilter(request, filters[request.name]) })));
+const daffApplyRequestToFilters = (request, filters) => (Object.assign(Object.assign({}, filters), { [request.name]: daffApplyFilter(request, filters[request.name]) }));
 
 /**
- * @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 {?}
- */
-const daffApplyRequestsToFilters = (/**
- * @param {?} filtersRequests
- * @param {?} filters
- * @return {?}
- */
-(filtersRequests, filters) => filtersRequests.reduce((/**
- * @param {?} acc
- * @param {?} request
- * @return {?}
+ * @idempotent {filters}
  */
-(acc, request) => {
+const daffApplyRequestsToFilters = (filtersRequests, filters) => filtersRequests.reduce((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 {?}
- */
-const daffClearFilterEqual = (/**
- * @param {?} filter
- * @return {?}
+ * @idempotent {filter}
+ * @docs-private
  */
-(filter) => (Object.assign(Object.assign({}, filter), { options: Object.keys(filter.options).map((/**
-     * @param {?} key
-     * @return {?}
-     */
-    (key) => filter.options[key])).reduce((/**
-     * @param {?} acc
-     * @param {?} option
-     * @return {?}
-     */
-    (acc, option) => {
+const daffClearFilterEqual = (filter) => (Object.assign(Object.assign({}, filter), { options: Object.keys(filter.options).map((key) => filter.options[key]).reduce((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 {?}
- */
-const daffClearFilterRange = (/**
- * @template T, U
- * @param {?} filter
- * @return {?}
+ * @idempotent {filter}
+ * @docs-private
  */
-(filter) => (Object.assign(Object.assign({}, filter), { options: {} })));
+const daffClearFilterRange = (filter) => (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}
  */
-const daffClearFilter = (/**
- * @param {?} filter
- * @return {?}
- */
-(filter) => {
+const daffClearFilter = (filter) => {
     switch (filter.type) {
         case DaffCategoryFilterType.RangeNumeric:
             return daffClearFilterRange(filter);
@@ -581,338 +247,152 @@ const daffClearFilter = (/**
         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 {?}
- */
-const daffClearFilters = (/**
- * @param {?} filters
- * @return {?}
- */
-(filters) => Object.keys(filters).map((/**
- * @param {?} key
- * @return {?}
- */
-(key) => filters[key])).reduce((/**
- * @param {?} acc
- * @param {?} filter
- * @return {?}
+ * @idempotent {filters}
  */
-(acc, filter) => {
+const daffClearFilters = (filters) => Object.keys(filters).map((key) => filters[key]).reduce((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
  */
-const daffRemoveFilterEqual = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
- */
-(request, filter) => (Object.assign(Object.assign({}, filter), { options: request.value.reduce((/**
-     * @param {?} acc
-     * @param {?} value
-     * @return {?}
-     */
-    (acc, value) => {
-        /** @type {?} */
+const daffRemoveFilterEqual = (request, filter) => (Object.assign(Object.assign({}, filter), { options: request.value.reduce((acc, value) => {
         const 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 {?}
- */
-const daffRemoveFilterRange = (/**
- * @template T, U
- * @param {?} request
- * @param {?} filter
- * @return {?}
+ * @idempotent {filter}
+ * @docs-private
  */
-(request, filter) => filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
+const daffRemoveFilterRange = (request, filter) => 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 {?}
- */
-const daffRemoveFilter = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
+ * @idempotent {filter}
+ * @pure
  */
-(request, filter) => {
+const daffRemoveFilter = (request, filter) => {
     daffCategoryValidateFilterRequestNameMatch(request, filter);
     daffCategoryValidateFilterRequestTypeMatch(request, filter);
     switch (request.type) {
         case DaffCategoryFilterType.Equal:
-            return daffRemoveFilterEqual(request, (/** @type {?} */ (filter)));
+            return daffRemoveFilterEqual(request, filter);
         case (DaffCategoryFilterType.RangeNumeric):
-            return daffRemoveFilterRange(request, (/** @type {?} */ (filter)));
+            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 {?}
- */
-const daffRemoveRequestFromFilters = (/**
- * @param {?} request
- * @param {?} filters
- * @return {?}
+ * @idempotent {filters}
  */
-(request, filters) => (Object.assign(Object.assign({}, filters), { [request.name]: daffRemoveFilter(request, filters[request.name]) })));
+const daffRemoveRequestFromFilters = (request, filters) => (Object.assign(Object.assign({}, filters), { [request.name]: daffRemoveFilter(request, filters[request.name]) }));
 
 /**
- * @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}
  */
-const daffRemoveRequestsFromFilters = (/**
- * @param {?} requests
- * @param {?} filters
- * @return {?}
- */
-(requests, filters) => requests.reduce((/**
- * @param {?} acc
- * @param {?} request
- * @return {?}
- */
-(acc, request) => {
+const daffRemoveRequestsFromFilters = (requests, filters) => requests.reduce((acc, request) => {
     acc[request.name] = daffRemoveFilter(request, filters[request.name]);
     return acc;
-}), Object.assign({}, filters)));
+}, 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
- */
-
-/**
- * @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
  */
-const daffToggleFilterEqual = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
- */
-(request, filter) => {
-    /** @type {?} */
+const daffToggleFilterEqual = (request, filter) => {
     const option = filter.options[request.value];
     return option
         ? Object.assign(Object.assign({}, filter), { options: Object.assign(Object.assign({}, filter.options), { [option.value]: Object.assign(Object.assign({}, option), { applied: !option.applied }) }) }) : 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
  */
-const daffToggleFilterRange = (/**
- * @template T, U
- * @param {?} request
- * @param {?} filter
- * @return {?}
- */
-(request, filter) => filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
+const daffToggleFilterRange = (request, filter) => 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)));
+            return daffToggleFilterEqual(request, filter);
         case (DaffCategoryFilterType.RangeNumeric):
-            return daffToggleFilterRange(request, (/** @type {?} */ (filter)));
+            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 {?}
- */
-const daffToggleRequestOnFilters = (/**
- * @param {?} request
- * @param {?} filters
- * @return {?}
- */
-(request, filters) => (Object.assign(Object.assign({}, filters), { [request.name]: daffToggleFilter(request, filters[request.name]) })));
+const daffToggleRequestOnFilters = (request, filters) => (Object.assign(Object.assign({}, filters), { [request.name]: daffToggleFilter(request, filters[request.name]) }));
 
 /**
- * @fileoverview added by tsickle
- * Generated from: filters/behaviors/toggle/public_api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Determines whether or not the {@link DaffCategoryFilterEqual} has any applied options.
  */
+const daffIsFilterEqualApplied = (filter) => Object.keys(filter.options).map((key) => filter.options[key]).findIndex(option => option.applied) > -1;
 
 /**
- * @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 {?}
- */
-const daffIsFilterEqualApplied = (/**
- * @param {?} filter
- * @return {?}
- */
-(filter) => Object.keys(filter.options).map((/**
- * @param {?} key
- * @return {?}
+ * Determines whether or not a {@link DaffCategoryFilterRangeBase} has any applied options.
  */
-(key) => filter.options[key])).findIndex((/**
- * @param {?} option
- * @return {?}
- */
-option => 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 {?}
- */
-const daffIsFilterRangeApplied = (/**
- * @template T
- * @param {?} filter
- * @return {?}
- */
-(filter) => Object.keys(filter.options).length > 0);
+const daffIsFilterRangeApplied = (filter) => 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 {?}
  */
-const daffIsFilterApplied = (/**
- * @param {?} filter
- * @return {?}
- */
-(filter) => {
+const daffIsFilterApplied = (filter) => {
     switch (filter.type) {
         case DaffCategoryFilterType.RangeNumeric:
             return daffIsFilterRangeApplied(filter);
@@ -921,117 +401,41 @@ const daffIsFilterApplied = (/**
         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 {?}
- */
-const daffIsEqualToggleRequestAppliedToFilter = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
+ * Determines whether or not any {@link DaffCategoryFilterEqual} options matching {@link DaffCategoryFilterEqualToggleRequest} are applied.
  */
-(request, filter) => { var _a; return !!((_a = filter.options[request.value]) === null || _a === void 0 ? void 0 : _a.applied); });
+const daffIsEqualToggleRequestAppliedToFilter = (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 {?}
- */
-const daffIsRangeToggleRequestAppliedToFilter = (/**
- * @template T
- * @param {?} request
- * @param {?} filter
- * @return {?}
- */
-(request, filter) => daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max) in filter.options);
+const daffIsRangeToggleRequestAppliedToFilter = (request, filter) => 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}.
  */
-/**
- * Determines whether or not a {\@link DaffCategoryFilterToggleRequest} is already applied to a {\@link DaffCategoryFilter}.
- * @type {?}
- */
-const daffIsToggleRequestAppliedToFilter = (/**
- * @param {?} request
- * @param {?} filter
- * @return {?}
- */
-(request, filter) => {
+const daffIsToggleRequestAppliedToFilter = (request, filter) => {
     switch (filter.type) {
         case DaffCategoryFilterType.RangeNumeric:
-            return daffIsRangeToggleRequestAppliedToFilter((/** @type {?} */ (request)), filter);
+            return daffIsRangeToggleRequestAppliedToFilter(request, filter);
         case DaffCategoryFilterType.Equal:
-            return daffIsEqualToggleRequestAppliedToFilter((/** @type {?} */ (request)), filter);
+            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 {?}
- */
-const daffCategoryFindAppliedFilterOptions = (/**
- * @template T
- * @param {?} filter
- * @return {?}
- */
-(filter) => Object.keys(filter.options).map((/**
- * @param {?} key
- * @return {?}
- */
-(key) => (/** @type {?} */ (filter.options[key])))).filter((/**
- * @param {?} option
- * @return {?}
- */
-(option) => 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
  */
+const daffCategoryFindAppliedFilterOptions = (filter) => Object.keys(filter.options).map((key) => filter.options[key]).filter((option) => option.applied);
 
 /**
- * @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.
  */
-/**
- * Builds an {\@link DaffCategoryFilterEqualRequest} from the passed filter and options.
- * @type {?}
- */
-const daffCategoryFilterEqualToRequest = (/**
- * @param {?} filter
- * @return {?}
- */
-(filter) => {
-    /** @type {?} */
+const daffCategoryFilterEqualToRequest = (filter) => {
     const options = daffCategoryFindAppliedFilterOptions(filter);
     if (!options.length) {
         return null;
@@ -1039,30 +443,14 @@ const daffCategoryFilterEqualToRequest = (/**
     return {
         type: DaffCategoryFilterType.Equal,
         name: filter.name,
-        value: options.map((/**
-         * @param {?} option
-         * @return {?}
-         */
-        option => option.value)),
+        value: options.map(option => 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.
  */
-/**
- * Builds a {\@link DaffCategoryFilterRangeRequestBase} from the passed {\@link DaffCategoryFilterRangeBase} and options.
- * @type {?}
- */
-const daffCategoryFilterRangeToRequest = (/**
- * @template T, U
- * @param {?} filter
- * @return {?}
- */
-(filter) => {
-    /** @type {?} */
+const daffCategoryFilterRangeToRequest = (filter) => {
     const options = daffCategoryFindAppliedFilterOptions(filter);
     if (!options.length) {
         return null;
@@ -1075,33 +463,16 @@ const daffCategoryFilterRangeToRequest = (/**
             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}
- * @type {?}
- */
-const daffCategoryFilterRangeNumericToRequest = (/**
- * @param {?} filter
- * @return {?}
+ * Transforms a {@link DaffCategoryFilterRangeNumeric} into a {@link DaffCategoryFilterRangeNumericRequest}
  */
-(filter) => (/** @type {?} */ (daffCategoryFilterRangeToRequest(filter))));
+const daffCategoryFilterRangeNumericToRequest = (filter) => 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) {
@@ -1115,175 +486,51 @@ function daffCategoryFilterToRequest(filter) {
 }
 ;
 
-/**
- * @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 {?}
-     */
-    (key) => filters[key])).reduce((/**
-     * @param {?} acc
-     * @param {?} filter
-     * @return {?}
-     */
-    (acc, filter) => {
-        /** @type {?} */
+    return Object.keys(filters).map((key) => filters[key]).reduce((acc, filter) => {
         const 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 {?}
- */
-const daffCategoryFilterRangePairArrayToDict = (/**
- * @template T
- * @param {?} pairs
- * @return {?}
- */
-(pairs) => daffArrayToDict(pairs, (/**
- * @param {?} pair
- * @return {?}
- */
-pair => 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>}.
  */
+const daffCategoryFilterRangePairArrayToDict = (pairs) => daffArrayToDict(pairs, pair => 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 {?}
- */
-const daffCategoryFilterEqualOptionArrayToDict = (/**
- * @param {?} options
- * @return {?}
- */
-(options) => daffArrayToDict(options, (/**
- * @param {?} option
- * @return {?}
- */
-option => 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
  */
+const daffCategoryFilterEqualOptionArrayToDict = (options) => daffArrayToDict(options, option => option.value);
 
 /**
- * @fileoverview added by tsickle
- * Generated from: filters/errors/public_api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @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 {?}
- */
-const daffCategoryFilterArrayToDict = (/**
- * @param {?} filters
- * @return {?}
- */
-(filters) => daffArrayToDict(filters, (/**
- * @param {?} filter
- * @return {?}
+ * Converts a list of category filters into a {@link Dict} of filters keyed by filter name.
  */
-filter => filter.name)));
+const daffCategoryFilterArrayToDict = (filters) => daffArrayToDict(filters, filter => 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 {?}
- */
-const daffCategoryComputeAppliedFilters = (/**
- * @param {?} filters
- * @return {?}
- */
-(filters) => Object.keys(filters).map((/**
- * @param {?} key
- * @return {?}
- */
-key => filters[key])).reduce((/**
- * @param {?} acc
- * @param {?} filter
- * @return {?}
- */
-(acc, filter) => {
-    /** @type {?} */
+const daffCategoryComputeAppliedFilters = (filters) => Object.keys(filters).map(key => filters[key]).reduce((acc, filter) => {
     const 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))) });
+                ? 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.
  */
 
 export { DAFF_CATEGORY_ERROR_MATCHER, DaffCategoryErrorCodes, DaffCategoryErrorMap, DaffCategoryFilterNotFound, DaffCategoryFilterRequestNameMismatch, DaffCategoryFilterRequestTypeMismatch, DaffCategoryFilterType, DaffCategoryFromToFilterSeparator, DaffCategoryRequestKind, DaffCategoryUnknownFilterType, daffApplyFilter, daffApplyRequestToFilters, daffApplyRequestsToFilters, daffCategoryComputeAppliedFilters, daffCategoryComputeFilterRangePairLabel, daffCategoryFilterArrayToDict, daffCategoryFilterEqualOptionArrayToDict, daffCategoryFilterRangePairArrayToDict, daffCategoryFilterToRequest, daffCategoryFiltersToRequests, daffCategoryFindAppliedFilterOptions, daffCategoryValidateFilterRequestNameMatch, daffCategoryValidateFilterRequestTypeMatch, daffClearFilter, daffClearFilters, daffIsFilterApplied, daffIsToggleRequestAppliedToFilter, daffRemoveFilter, daffRemoveRequestFromFilters, daffRemoveRequestsFromFilters, daffToggleFilter, daffToggleRequestOnFilters };