@daffodil/core 0.94.1 → 0.95.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,29 +1,26 @@
1
- import * as i0 from '@angular/core';
2
- import { EnvironmentProviders, InjectionToken, ValueProvider, FactoryProvider, Type, ExistingProvider } from '@angular/core';
3
- import * as rxjs from 'rxjs';
4
- import { Observable } from 'rxjs';
5
-
1
+ import "@angular/common";
2
+ import * as i0 from "@angular/core";
3
+ import { EnvironmentProviders, ExistingProvider, FactoryProvider, InjectionToken, Type, ValueProvider } from "@angular/core";
4
+ import { Observable } from "rxjs";
6
5
  /**
7
6
  * An object that has a location referenced by a URL.
8
7
  */
9
- interface DaffLocatable {
10
- /**
11
- * The URL describing the location of the entity.
12
- * It should be relative to the domain root with a leading slash, i.e. `/path/to/entity`.
13
- */
14
- url: string;
8
+ export interface DaffLocatable {
9
+ /**
10
+ * The URL describing the location of the entity.
11
+ * It should be relative to the domain root with a leading slash, i.e. `/path/to/entity`.
12
+ */
13
+ url: string;
15
14
  }
16
-
17
15
  /**
18
16
  * An object that has a canonical location referenced by a URL.
19
17
  */
20
- interface DaffCanonicallyLocatable {
21
- /**
22
- * The URL describing the canonical location of the entity.
23
- */
24
- canonicalUrl: string;
18
+ export interface DaffCanonicallyLocatable {
19
+ /**
20
+ * The URL describing the canonical location of the entity.
21
+ */
22
+ canonicalUrl: string;
25
23
  }
26
-
27
24
  /**
28
25
  * A type which describes a function which would return an instance of a class
29
26
  * Typically, we call this the "new" method in a language.
@@ -47,20 +44,19 @@ interface DaffCanonicallyLocatable {
47
44
  *
48
45
  * ```
49
46
  */
50
- type Constructable<T, Args extends Array<any> = Array<any>> = new (...args: Args) => T;
51
-
47
+ export type Constructable<T, Args extends Array<any> = Array<any>> = new (...args: Args) => T;
52
48
  /**
53
49
  * Configuration interface for Vercel image optimization settings.
54
50
  */
55
51
  interface VercelAssetsConfig {
56
- /**
57
- * Default width to use when no width is specified in the image config.
58
- */
59
- defaultWidth: number;
60
- /**
61
- * Image quality setting (0-100) for Vercel image optimization.
62
- */
63
- quality: number;
52
+ /**
53
+ * Default width to use when no width is specified in the image config.
54
+ */
55
+ defaultWidth: number;
56
+ /**
57
+ * Image quality setting (0-100) for Vercel image optimization.
58
+ */
59
+ quality: number;
64
60
  }
65
61
  /**
66
62
  * Provides a Vercel image loader as an Angular environment provider.
@@ -69,170 +65,159 @@ interface VercelAssetsConfig {
69
65
  * @param configuration Configuration options for image optimization
70
66
  * @returns Environment providers array containing the Vercel image loader
71
67
  */
72
- declare const provideVercelImageLoader: (domain: string, configuration: VercelAssetsConfig) => EnvironmentProviders;
73
-
68
+ export declare const provideVercelImageLoader: (domain: string, configuration: VercelAssetsConfig) => EnvironmentProviders;
74
69
  /**
75
70
  * A service for encoding and decoding base64 strings.
76
71
  */
77
- interface DaffBase64Service {
78
- /**
79
- * Encodes an ASCII string to base64.
80
- */
81
- encode(str: string): string;
82
- /**
83
- * Decodes a base64 string to ASCII.
84
- */
85
- decode(str: string): string;
72
+ export interface DaffBase64Service {
73
+ /**
74
+ * Encodes an ASCII string to base64.
75
+ */
76
+ encode(str: string): string;
77
+ /**
78
+ * Decodes a base64 string to ASCII.
79
+ */
80
+ decode(str: string): string;
86
81
  }
87
- declare const DaffBase64ServiceToken: i0.InjectionToken<DaffBase64Service>;
88
-
82
+ declare const DaffBase64ServiceToken: import("@angular/core").InjectionToken<DaffBase64Service>, provideDaffBase64Service: <R extends DaffBase64Service = DaffBase64Service>(value: R) => import("@angular/core").ValueProvider;
89
83
  /**
90
84
  * A base64 service meant to be loaded into SSR contexts.
91
85
  *
92
86
  * @inheritdoc
93
87
  */
94
- declare class DaffServerBase64Service implements DaffBase64Service {
95
- constructor(platformId: string);
96
- encode(str: string): string;
97
- decode(str: string): string;
98
- static ɵfac: i0.ɵɵFactoryDeclaration<DaffServerBase64Service, never>;
99
- static ɵprov: i0.ɵɵInjectableDeclaration<DaffServerBase64Service>;
88
+ export declare class DaffServerBase64Service implements DaffBase64Service {
89
+ constructor(platformId: string);
90
+ encode(str: string): string;
91
+ decode(str: string): string;
92
+ static ɵfac: i0.ɵɵFactoryDeclaration<DaffServerBase64Service, never>;
93
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
100
94
  }
101
-
102
95
  /**
103
96
  * @inheritdoc
104
97
  */
105
- declare class DaffBrowserBase64Service implements DaffBase64Service {
106
- constructor(platformId: string);
107
- encode(str: string): string;
108
- decode(str: string): string;
109
- static ɵfac: i0.ɵɵFactoryDeclaration<DaffBrowserBase64Service, never>;
110
- static ɵprov: i0.ɵɵInjectableDeclaration<DaffBrowserBase64Service>;
98
+ export declare class DaffBrowserBase64Service implements DaffBase64Service {
99
+ constructor(platformId: string);
100
+ encode(str: string): string;
101
+ decode(str: string): string;
102
+ static ɵfac: i0.ɵɵFactoryDeclaration<DaffBrowserBase64Service, never>;
103
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
111
104
  }
112
-
113
105
  /**
114
106
  * The interface that describes a collection of elements that can be navigated in
115
107
  * a paged way. E.g. "Pages 1,2,3,4,5".
116
108
  *
117
109
  */
118
- interface DaffNumericallyPaginable {
119
- currentPage: number;
120
- totalPages: number;
121
- pageSize: number;
110
+ export interface DaffNumericallyPaginable {
111
+ currentPage: number;
112
+ totalPages: number;
113
+ pageSize: number;
122
114
  }
123
-
124
115
  /**
125
116
  * The metadata that describes the sorting behavior of a collection of elements.
126
117
  */
127
- interface DaffSortOptions {
128
- default: DaffSortOption['value'];
129
- options: DaffSortOption[];
118
+ export interface DaffSortOptions {
119
+ default: DaffSortOption['value'];
120
+ options: DaffSortOption[];
130
121
  }
131
122
  /**
132
123
  * One particular option used to sort a collection of elements;
133
124
  */
134
- interface DaffSortOption {
135
- label: string;
136
- value: any;
125
+ export interface DaffSortOption {
126
+ label: string;
127
+ value: any;
137
128
  }
138
129
  /**
139
130
  * The direction in which to sort a list of elements, e.g. if the list was
140
131
  * sorted alphabetically, "Ascending" would be from "A-Z",
141
132
  * and "Descending" would be from "Z-A".
142
133
  */
143
- declare enum DaffSortDirectionEnum {
144
- Ascending = "ASC",
145
- Descending = "DSC"
134
+ export declare enum DaffSortDirectionEnum {
135
+ Ascending = "ASC",
136
+ Descending = "DSC"
146
137
  }
147
138
  /**
148
139
  * Describes the properties of a collection that make the collection able to be
149
140
  * sorted by Daffodil.
150
141
  */
151
- interface DaffSortable {
152
- /**
153
- * The available options by which to sort the collection.
154
- */
155
- sortOptions: DaffSortOptions;
156
- /**
157
- * The currently applied sorting option.
158
- */
159
- appliedSortOption: DaffSortOption['value'];
160
- /**
161
- * The currently applied sort direction.
162
- */
163
- appliedSortDirection: DaffSortDirectionEnum;
142
+ export interface DaffSortable {
143
+ /**
144
+ * The available options by which to sort the collection.
145
+ */
146
+ sortOptions: DaffSortOptions;
147
+ /**
148
+ * The currently applied sorting option.
149
+ */
150
+ appliedSortOption: DaffSortOption['value'];
151
+ /**
152
+ * The currently applied sort direction.
153
+ */
154
+ appliedSortDirection: DaffSortDirectionEnum;
164
155
  }
165
-
166
156
  /**
167
157
  * Represents an entity that contains a countable number of items.
168
158
  */
169
- interface DaffCountable {
170
- /**
171
- * The number of items contained or tracked by this entity.
172
- */
173
- count: number;
159
+ export interface DaffCountable {
160
+ /**
161
+ * The number of items contained or tracked by this entity.
162
+ */
163
+ count: number;
174
164
  }
175
-
176
165
  /**
177
166
  * The base type of a filter option.
178
167
  */
179
- interface DaffFilterOptionBase {
180
- /**
181
- * Whether or not the filter option is applied.
182
- */
183
- applied: boolean;
168
+ export interface DaffFilterOptionBase {
169
+ /**
170
+ * Whether or not the filter option is applied.
171
+ */
172
+ applied: boolean;
184
173
  }
185
-
186
174
  /**
187
175
  * The known types of filters.
188
176
  */
189
- declare enum DaffFilterType {
190
- Equal = "equal",
191
- RangeNumeric = "rangeNumeric"
177
+ export declare enum DaffFilterType {
178
+ Equal = "equal",
179
+ RangeNumeric = "rangeNumeric"
192
180
  }
193
-
194
181
  /**
195
182
  * The base type of a filter.
196
183
  */
197
- interface DaffFilterBase {
198
- /**
199
- * The end-user facing string that explains the filter e.g. "Color".
200
- */
201
- label: string;
202
- /**
203
- * The name of the filter e.g. "color".
204
- */
205
- name: string;
206
- /**
207
- * The type of the filter. This is used to determine the specific behavior of the filter.
208
- */
209
- type: DaffFilterType;
210
- /**
211
- * The available options by which to filter a collection entity, e.g. "red", "blue", or "green".
212
- * The type of options changes per type of filter.
213
- */
214
- options: Record<string, DaffFilterOptionBase>;
184
+ export interface DaffFilterBase {
185
+ /**
186
+ * The end-user facing string that explains the filter e.g. "Color".
187
+ */
188
+ label: string;
189
+ /**
190
+ * The name of the filter e.g. "color".
191
+ */
192
+ name: string;
193
+ /**
194
+ * The type of the filter. This is used to determine the specific behavior of the filter.
195
+ */
196
+ type: DaffFilterType;
197
+ /**
198
+ * The available options by which to filter a collection entity, e.g. "red", "blue", or "green".
199
+ * The type of options changes per type of filter.
200
+ */
201
+ options: Record<string, DaffFilterOptionBase>;
215
202
  }
216
-
217
203
  /**
218
204
  * The individual options applicable to a filter. Such an option may be something like
219
205
  * "Red" or "Green", "Tall" or "Short", etc.
220
206
  */
221
- interface DaffFilterEqualOption extends DaffFilterOptionBase {
222
- /**
223
- * The id of the filter option.
224
- */
225
- value: string;
226
- /**
227
- * A label to represent the filter option in the UI.
228
- */
229
- label: string;
230
- /**
231
- * The number of entities that would be returned after application of this filter.
232
- */
233
- count: number;
207
+ export interface DaffFilterEqualOption extends DaffFilterOptionBase {
208
+ /**
209
+ * The id of the filter option.
210
+ */
211
+ value: string;
212
+ /**
213
+ * A label to represent the filter option in the UI.
214
+ */
215
+ label: string;
216
+ /**
217
+ * The number of entities that would be returned after application of this filter.
218
+ */
219
+ count: number;
234
220
  }
235
-
236
221
  /**
237
222
  * A DaffFilterEqual is used to represent filters where
238
223
  * there is a set of well-defined dictionary-like values that are exactly
@@ -244,51 +229,48 @@ interface DaffFilterEqualOption extends DaffFilterOptionBase {
244
229
  * options are applied to collections of items, items that are "Red" AND "Green" vs.
245
230
  * items that are "Red" OR "Green".
246
231
  */
247
- interface DaffFilterEqual extends DaffFilterBase {
248
- /**
249
- * The filter type for this model is always of type "DaffFilterType.Equal".
250
- */
251
- type: DaffFilterType.Equal;
252
- /**
253
- * A dictionary of filter options.
254
- */
255
- options: Record<DaffFilterEqualOption['value'], DaffFilterEqualOption>;
232
+ export interface DaffFilterEqual extends DaffFilterBase {
233
+ /**
234
+ * The filter type for this model is always of type "DaffFilterType.Equal".
235
+ */
236
+ type: DaffFilterType.Equal;
237
+ /**
238
+ * A dictionary of filter options.
239
+ */
240
+ options: Record<DaffFilterEqualOption['value'], DaffFilterEqualOption>;
256
241
  }
257
-
258
242
  /**
259
243
  * A particular option of a range pair.
260
244
  * Holds a value and a label.
261
245
  */
262
- interface DaffFilterRangeOption<T> {
263
- /**
264
- * The value for the range option; e.g. "10" for a price range option.
265
- */
266
- value: T;
267
- /**
268
- * A label to represent the range option in the UI.
269
- */
270
- label: string;
246
+ export interface DaffFilterRangeOption<T> {
247
+ /**
248
+ * The value for the range option; e.g. "10" for a price range option.
249
+ */
250
+ value: T;
251
+ /**
252
+ * A label to represent the range option in the UI.
253
+ */
254
+ label: string;
271
255
  }
272
-
273
256
  /**
274
257
  * An pair of options of the range filter.
275
258
  * Specifies a pair of min and max values.
276
259
  */
277
- interface DaffFilterRangePair<T> extends DaffFilterOptionBase {
278
- /**
279
- * The range pair is always set to applied, because a filter range pair exists if it is applied and does not exist if it is not applied.
280
- */
281
- applied: true;
282
- /**
283
- * The minimum range option of the filter range pair.
284
- */
285
- min: DaffFilterRangeOption<T>;
286
- /**
287
- * The maximum range option of the filter range pair.
288
- */
289
- max: DaffFilterRangeOption<T>;
260
+ export interface DaffFilterRangePair<T> extends DaffFilterOptionBase {
261
+ /**
262
+ * The range pair is always set to applied, because a filter range pair exists if it is applied and does not exist if it is not applied.
263
+ */
264
+ applied: true;
265
+ /**
266
+ * The minimum range option of the filter range pair.
267
+ */
268
+ min: DaffFilterRangeOption<T>;
269
+ /**
270
+ * The maximum range option of the filter range pair.
271
+ */
272
+ max: DaffFilterRangeOption<T>;
290
273
  }
291
-
292
274
  /**
293
275
  * A base type for a range-style filter where there is a continuous distribution
294
276
  * that can be selected from. E.g. numbers from 0 through 100, letters from "a"
@@ -296,233 +278,211 @@ interface DaffFilterRangePair<T> extends DaffFilterOptionBase {
296
278
  *
297
279
  * Note that this is the generic base allowing for stricter type implementations.
298
280
  */
299
- interface DaffFilterRangeBase<T> extends DaffFilterBase {
300
- /**
301
- * The minimum value for the filter range.
302
- */
303
- min: T;
304
- /**
305
- * The maximum value for the filter range.
306
- */
307
- max: T;
308
- /**
309
- * A dictionary of filter range options.
310
- */
311
- options: Record<string, DaffFilterRangePair<T>>;
281
+ export interface DaffFilterRangeBase<T> extends DaffFilterBase {
282
+ /**
283
+ * The minimum value for the filter range.
284
+ */
285
+ min: T;
286
+ /**
287
+ * The maximum value for the filter range.
288
+ */
289
+ max: T;
290
+ /**
291
+ * A dictionary of filter range options.
292
+ */
293
+ options: Record<string, DaffFilterRangePair<T>>;
312
294
  }
313
-
314
295
  /**
315
296
  * The separator between a range type filter's values
316
297
  * e.g. "price": "30-40".
317
298
  */
318
- declare const DaffFilterFromToFilterSeparator = "-";
319
-
299
+ export declare const DaffFilterFromToFilterSeparator = "-";
320
300
  /**
321
301
  * The base interface for range requests. Range requests have a name and a
322
302
  * single defining the min and max values between which to filter.
323
303
  */
324
- interface DaffFilterRangeRequestBase<T> {
325
- /**
326
- * The type of filter.
327
- */
328
- type: DaffFilterType;
329
- /**
330
- * The name/code of the filter; e.g. price.
331
- */
332
- name: string;
333
- /**
334
- * The value of the filter range.
335
- */
336
- value: DaffFilterRangeRequestOption<T>;
304
+ export interface DaffFilterRangeRequestBase<T> {
305
+ /**
306
+ * The type of filter.
307
+ */
308
+ type: DaffFilterType;
309
+ /**
310
+ * The name/code of the filter; e.g. price.
311
+ */
312
+ name: string;
313
+ /**
314
+ * The value of the filter range.
315
+ */
316
+ value: DaffFilterRangeRequestOption<T>;
337
317
  }
338
-
339
318
  /**
340
319
  * The request option represents the minimum and maximum values that
341
320
  * are going to be filtered as defined by a {@link DaffFilterRangeRequestBase}.
342
321
  */
343
- interface DaffFilterRangeRequestOption<T> {
344
- /**
345
- * The minimum value of the filter range.
346
- */
347
- min: T;
348
- /**
349
- * The maximum value of the filter range.
350
- */
351
- max: T;
322
+ export interface DaffFilterRangeRequestOption<T> {
323
+ /**
324
+ * The minimum value of the filter range.
325
+ */
326
+ min: T;
327
+ /**
328
+ * The maximum value of the filter range.
329
+ */
330
+ max: T;
352
331
  }
353
-
354
332
  /**
355
333
  * An interface that describes filters that are a range of numbers; i.e. prices.
356
334
  */
357
- interface DaffFilterRangeNumeric extends DaffFilterRangeBase<number> {
358
- /**
359
- * The type of filter.
360
- */
361
- type: DaffFilterType.RangeNumeric;
335
+ export interface DaffFilterRangeNumeric extends DaffFilterRangeBase<number> {
336
+ /**
337
+ * The type of filter.
338
+ */
339
+ type: DaffFilterType.RangeNumeric;
362
340
  }
363
-
364
341
  /**
365
342
  * A single filter along with its options. For example, a filter may be
366
343
  * something like "Color" with options of "Red", "Blue", and "Green".
367
344
  *
368
345
  * Importantly, filters have "types" which determine their behavior. See {@link DaffFilterType} for a complete list.
369
346
  */
370
- type DaffFilter = DaffFilterRangeNumeric | DaffFilterEqual;
371
-
347
+ export type DaffFilter = DaffFilterRangeNumeric | DaffFilterEqual;
372
348
  /**
373
349
  * A dictionary of {@link DaffFilter}s keyed by name.
374
350
  */
375
- type DaffFilters<T extends DaffFilter = DaffFilter> = Record<T['name'], T>;
376
-
351
+ export type DaffFilters<T extends DaffFilter = DaffFilter> = Record<T['name'], T>;
377
352
  /**
378
353
  * A given option of a particular filter, e.g. "Blue" is a DaffFilterOption
379
354
  * of the {@link DaffFilter} "Color".
380
355
  */
381
- type DaffFilterOption = DaffFilter['options'][string];
382
-
356
+ export type DaffFilterOption = DaffFilter['options'][string];
383
357
  /**
384
358
  * A request used to modify the applied status of a {@link DaffFilterEqual}.
385
359
  */
386
- interface DaffFilterEqualRequest {
387
- /**
388
- * The type of filter request.
389
- */
390
- type: DaffFilterType.Equal;
391
- /**
392
- * The name of the filter; e.g. color.
393
- */
394
- name: string;
395
- /**
396
- * An array of filter options; e.g. green and red.
397
- */
398
- value: string[];
360
+ export interface DaffFilterEqualRequest {
361
+ /**
362
+ * The type of filter request.
363
+ */
364
+ type: DaffFilterType.Equal;
365
+ /**
366
+ * The name of the filter; e.g. color.
367
+ */
368
+ name: string;
369
+ /**
370
+ * An array of filter options; e.g. green and red.
371
+ */
372
+ value: string[];
399
373
  }
400
-
401
374
  /**
402
375
  * Describes filter range requests for numbers; i.e. prices.
403
376
  */
404
- interface DaffFilterRangeNumericRequest extends DaffFilterRangeRequestBase<number> {
405
- /**
406
- * The filter type.
407
- */
408
- type: DaffFilterType.RangeNumeric;
377
+ export interface DaffFilterRangeNumericRequest extends DaffFilterRangeRequestBase<number> {
378
+ /**
379
+ * The filter type.
380
+ */
381
+ type: DaffFilterType.RangeNumeric;
409
382
  }
410
-
411
383
  /**
412
384
  * A DaffFilterRequest is used to modify the applied or unapplied state of
413
385
  * the options of a {@link DaffFilter}.
414
386
  */
415
- type DaffFilterRequest = DaffFilterEqualRequest | DaffFilterRangeNumericRequest;
416
-
387
+ export type DaffFilterRequest = DaffFilterEqualRequest | DaffFilterRangeNumericRequest;
417
388
  /**
418
389
  * A request used to toggle the applied status of a {@link DaffFilterEqual}.
419
390
  */
420
- interface DaffFilterEqualToggleRequest {
421
- /**
422
- * The type of filter request.
423
- */
424
- type: DaffFilterType.Equal;
425
- /**
426
- * The name of the filter; e.g. color.
427
- */
428
- name: string;
429
- /**
430
- * The value of the filter option; e.g. red.
431
- */
432
- value: string;
391
+ export interface DaffFilterEqualToggleRequest {
392
+ /**
393
+ * The type of filter request.
394
+ */
395
+ type: DaffFilterType.Equal;
396
+ /**
397
+ * The name of the filter; e.g. color.
398
+ */
399
+ name: string;
400
+ /**
401
+ * The value of the filter option; e.g. red.
402
+ */
403
+ value: string;
433
404
  }
434
-
435
405
  /**
436
406
  * An interface to describe toggle requests for ranged numeric filters. For example, the request could be to
437
407
  * toggle a price filter for the "10-20" range.
438
408
  */
439
- interface DaffFilterRangeNumericToggleRequest extends DaffFilterRangeRequestBase<number> {
440
- /**
441
- * The filter type.
442
- */
443
- type: DaffFilterType.RangeNumeric;
409
+ export interface DaffFilterRangeNumericToggleRequest extends DaffFilterRangeRequestBase<number> {
410
+ /**
411
+ * The filter type.
412
+ */
413
+ type: DaffFilterType.RangeNumeric;
444
414
  }
445
-
446
415
  /**
447
416
  * A DaffFilterToggleRequest is used to toggle a filter option between an applied and unapplied state.
448
417
  */
449
- type DaffFilterToggleRequest = DaffFilterEqualToggleRequest | DaffFilterRangeNumericToggleRequest;
450
-
418
+ export type DaffFilterToggleRequest = DaffFilterEqualToggleRequest | DaffFilterRangeNumericToggleRequest;
451
419
  /**
452
420
  * Describes an object that allows a specific entity to be filterable.
453
421
  */
454
- interface DaffFilterable {
455
- /**
456
- * The available filters.
457
- */
458
- filters: DaffFilters;
422
+ export interface DaffFilterable {
423
+ /**
424
+ * The available filters.
425
+ */
426
+ filters: DaffFilters;
459
427
  }
460
-
461
- type ID = string;
462
-
428
+ export type ID = string;
463
429
  /**
464
430
  * An object that has an identifier.
465
431
  */
466
- interface DaffIdentifiable {
467
- /**
468
- * The identifier.
469
- */
470
- id: ID;
432
+ export interface DaffIdentifiable {
433
+ /**
434
+ * The identifier.
435
+ */
436
+ id: ID;
471
437
  }
472
-
473
438
  /**
474
439
  * Transforms an array of {@link DaffIdentifiable} objects to a dictionary of those objects keyed by ID.
475
440
  */
476
- declare const daffIdentifiableArrayToDict: <T extends DaffIdentifiable = DaffIdentifiable>(ary: T[]) => Record<T["id"], T>;
477
-
441
+ export declare const daffIdentifiableArrayToDict: <T extends DaffIdentifiable = DaffIdentifiable>(ary: T[]) => Record<T["id"], T>;
478
442
  /**
479
443
  * The collection metadata contains info about the collection as a whole
480
444
  * such as pagination, sorting, and size.
481
445
  */
482
- interface DaffCollectionMetadata extends DaffNumericallyPaginable, DaffSortable, DaffCountable, DaffFilterable {
483
- ids: DaffIdentifiable['id'][];
446
+ export interface DaffCollectionMetadata extends DaffNumericallyPaginable, DaffSortable, DaffCountable, DaffFilterable {
447
+ ids: DaffIdentifiable['id'][];
484
448
  }
485
-
486
449
  /**
487
450
  * A collection of items that is paginable, sortable, and filterable.
488
451
  */
489
- interface DaffCollection<T extends DaffIdentifiable = DaffIdentifiable> {
490
- /**
491
- * The collection metadata that contains info about the collection.
492
- * Includes page, sorting, filtering, and total number of items.
493
- */
494
- metadata: DaffCollectionMetadata;
495
- /**
496
- * The current page of items according to the sorting and filtering.
497
- */
498
- data: Record<T['id'], T>;
452
+ export interface DaffCollection<T extends DaffIdentifiable = DaffIdentifiable> {
453
+ /**
454
+ * The collection metadata that contains info about the collection.
455
+ * Includes page, sorting, filtering, and total number of items.
456
+ */
457
+ metadata: DaffCollectionMetadata;
458
+ /**
459
+ * The current page of items according to the sorting and filtering.
460
+ */
461
+ data: Record<T['id'], T>;
499
462
  }
500
-
501
463
  /**
502
464
  * An error object containing info about the exception that generated it.
503
465
  */
504
- interface DaffError extends Error {
505
- /**
506
- * A string that uniquely identifies the error.
507
- */
508
- code: string;
509
- /**
510
- * Contains additional relevant information to the cause and/or solution of the error.
511
- */
512
- message: string;
513
- /**
514
- * Whether the error is non-critical and recoverable or catastrophic and unrecoverable.
515
- */
516
- recoverable: boolean;
466
+ export interface DaffError extends Error {
467
+ /**
468
+ * A string that uniquely identifies the error.
469
+ */
470
+ code: string;
471
+ /**
472
+ * Contains additional relevant information to the cause and/or solution of the error.
473
+ */
474
+ message: string;
475
+ /**
476
+ * Whether the error is non-critical and recoverable or catastrophic and unrecoverable.
477
+ */
478
+ recoverable: boolean;
517
479
  }
518
-
519
480
  /**
520
481
  * A type for a dictionary of error codes to Daffodil errors.
521
482
  */
522
- interface DaffErrorCodeMap {
523
- [x: string]: Constructable<DaffError>;
483
+ export interface DaffErrorCodeMap {
484
+ [x: string]: Constructable<DaffError>;
524
485
  }
525
-
526
486
  /**
527
487
  * A class which allows you to appropriately check the inheritance of an error.
528
488
  *
@@ -540,81 +500,72 @@ interface DaffErrorCodeMap {
540
500
  * You will see unexpected things. This class fixes that issue as described here
541
501
  * https://github.com/microsoft/TypeScript/issues/13965
542
502
  */
543
- declare class DaffInheritableError extends Error {
544
- __proto__: Error;
545
- recoverable: boolean;
546
- constructor(message?: string);
503
+ export declare class DaffInheritableError extends Error {
504
+ __proto__: Error;
505
+ recoverable: boolean;
506
+ constructor(message?: string);
547
507
  }
548
-
549
508
  /**
550
509
  * Checks if the passed object is a {@link DaffError}
551
510
  */
552
- declare const daffIsError: (error: any) => boolean;
553
-
554
- declare const DAFF_COLLECTION_PAGE_OUT_OF_BOUNDS_ERROR_CODE = "DAFF_COLLECTION_PAGE_OUT_OF_BOUNDS";
511
+ export declare const daffIsError: (error: any) => boolean;
512
+ export declare const DAFF_COLLECTION_PAGE_OUT_OF_BOUNDS_ERROR_CODE = "DAFF_COLLECTION_PAGE_OUT_OF_BOUNDS";
555
513
  /**
556
514
  * An error thrown when the requested page is greater than the number of available pages.
557
515
  */
558
- declare class DaffCollectionPageOutOfBoundsError extends DaffInheritableError implements DaffError {
559
- readonly code: string;
560
- constructor(message?: string);
516
+ export declare class DaffCollectionPageOutOfBoundsError extends DaffInheritableError implements DaffError {
517
+ readonly code: string;
518
+ constructor(message?: string);
561
519
  }
562
-
563
- declare const daffCollectionErrorMap: {
564
- DAFF_COLLECTION_PAGE_OUT_OF_BOUNDS: typeof DaffCollectionPageOutOfBoundsError;
520
+ export declare const daffCollectionErrorMap: {
521
+ DAFF_COLLECTION_PAGE_OUT_OF_BOUNDS: typeof DaffCollectionPageOutOfBoundsError;
565
522
  };
566
-
567
523
  /**
568
524
  * A collection of items that is paginable, sortable, and filterable.
569
525
  */
570
- interface DaffCollectionRequest {
571
- /**
572
- * The option by which to sort the collection's items.
573
- */
574
- appliedSortOption?: string;
575
- /**
576
- * The direction by which to sort the collection's items.
577
- */
578
- appliedSortDirection?: DaffSortDirectionEnum;
579
- /**
580
- * What page of the collection's items to retrieve.
581
- */
582
- currentPage?: number;
583
- /**
584
- * The number of items per-page to request.
585
- */
586
- pageSize?: number;
587
- /**
588
- * The properties by which to filter the items of the collection being requested.
589
- */
590
- filterRequests?: DaffFilterRequest[];
526
+ export interface DaffCollectionRequest {
527
+ /**
528
+ * The option by which to sort the collection's items.
529
+ */
530
+ appliedSortOption?: string;
531
+ /**
532
+ * The direction by which to sort the collection's items.
533
+ */
534
+ appliedSortDirection?: DaffSortDirectionEnum;
535
+ /**
536
+ * What page of the collection's items to retrieve.
537
+ */
538
+ currentPage?: number;
539
+ /**
540
+ * The number of items per-page to request.
541
+ */
542
+ pageSize?: number;
543
+ /**
544
+ * The properties by which to filter the items of the collection being requested.
545
+ */
546
+ filterRequests?: DaffFilterRequest[];
591
547
  }
592
-
593
548
  /**
594
549
  * Extracts the part of the {@link DaffCollectionRequest} that can be directly set in {@link DaffCollectionMetadata}.
595
550
  */
596
- declare const daffCollectionBuildMetadataFromRequest: (request: DaffCollectionRequest) => Partial<DaffCollectionMetadata>;
597
-
551
+ export declare const daffCollectionBuildMetadataFromRequest: (request: DaffCollectionRequest) => Partial<DaffCollectionMetadata>;
598
552
  /**
599
553
  * Builds a {@link DaffCollectionRequest} from {@link DaffCollectionMetadata}.
600
554
  */
601
- declare const daffCollectionBuildRequestFromMetadata: (metadata: DaffCollectionMetadata) => Partial<DaffCollectionRequest>;
602
-
555
+ export declare const daffCollectionBuildRequestFromMetadata: (metadata: DaffCollectionMetadata) => Partial<DaffCollectionRequest>;
603
556
  /**
604
557
  * Represents an entity that has a creation date.
605
558
  */
606
- interface DaffCreateable {
607
- /**
608
- * The date at which this entity was created.
609
- */
610
- createdAt: string;
559
+ export interface DaffCreateable {
560
+ /**
561
+ * The date at which this entity was created.
562
+ */
563
+ createdAt: string;
611
564
  }
612
-
613
565
  /**
614
566
  * Finds and returns the most recently created entity.
615
567
  */
616
- declare function daffCreateableMostRecent<T extends DaffCreateable = DaffCreateable>(createables: T[]): T | null | undefined;
617
-
568
+ export declare function daffCreateableMostRecent<T extends DaffCreateable = DaffCreateable>(createables: T[]): T | null | undefined;
618
569
  /**
619
570
  * A utility decorator that delays method execution until after a specified delay period has elapsed since the last invocation.
620
571
  *
@@ -661,48 +612,42 @@ declare function daffCreateableMostRecent<T extends DaffCreateable = DaffCreatea
661
612
  * }
662
613
  * ```
663
614
  */
664
- declare const debounce: (delay?: number) => MethodDecorator;
665
-
615
+ export declare const debounce: (delay?: number) => MethodDecorator;
666
616
  /**
667
617
  * Applies a filter request to the matching filter.
668
618
  *
669
619
  * @idempotent {filter}
670
620
  * @throws {@link DaffFilterUnknownType}
671
621
  */
672
- declare const daffApplyFilter: (request: DaffFilterRequest, filter: DaffFilter) => DaffFilter;
673
-
622
+ export declare const daffApplyFilter: (request: DaffFilterRequest, filter: DaffFilter) => DaffFilter;
674
623
  /**
675
624
  * Applies a {@link DaffFilterRequest} to a dictionary of {@link DaffFilter}
676
625
  * returning the updated dictionary.
677
626
  *
678
627
  * @idempotent {filters}
679
628
  */
680
- declare const daffApplyRequestToFilters: (request: DaffFilterRequest, filters: DaffFilters) => DaffFilters;
681
-
629
+ export declare const daffApplyRequestToFilters: (request: DaffFilterRequest, filters: DaffFilters) => DaffFilters;
682
630
  /**
683
631
  * Applies filters from a {@link DaffFilterRequest} to a dictionary
684
632
  * of {@link DaffFilter}.
685
633
  *
686
634
  * @idempotent {filters}
687
635
  */
688
- declare const daffApplyRequestsToFilters: (filtersRequests: DaffFilterRequest[], filters: DaffFilters) => DaffFilters;
689
-
636
+ export declare const daffApplyRequestsToFilters: (filtersRequests: DaffFilterRequest[], filters: DaffFilters) => DaffFilters;
690
637
  /**
691
638
  * Undoes the applied state of all applied filter options of a {@link DaffFilter}
692
639
  * returning the filter.
693
640
  *
694
641
  * @idempotent {filter}
695
642
  */
696
- declare const daffClearFilter: (filter: DaffFilter) => DaffFilter;
697
-
643
+ export declare const daffClearFilter: (filter: DaffFilter) => DaffFilter;
698
644
  /**
699
645
  * Undoes the applied state of all applied filter options of a dictionary of {@link DaffFilter}
700
646
  * returning updated dictionary.
701
647
  *
702
648
  * @idempotent {filters}
703
649
  */
704
- declare const daffClearFilters: (filters: DaffFilters) => DaffFilters;
705
-
650
+ export declare const daffClearFilters: (filters: DaffFilters) => DaffFilters;
706
651
  /**
707
652
  * Undoes any applied options of a {@link DaffFilter} that match the
708
653
  * {@link DaffFilterRequest}, returning the {@link DaffFilter}.
@@ -710,16 +655,14 @@ declare const daffClearFilters: (filters: DaffFilters) => DaffFilters;
710
655
  * @idempotent {filter}
711
656
  * @pure
712
657
  */
713
- declare const daffRemoveFilter: (request: DaffFilterRequest, filter: DaffFilter) => DaffFilter;
714
-
658
+ export declare const daffRemoveFilter: (request: DaffFilterRequest, filter: DaffFilter) => DaffFilter;
715
659
  /**
716
660
  * Undoes any applied options of a particular filter of a dictionary of {@link DaffFilter}
717
661
  * that match the {@link DaffFilterRequest}, returning the dictionary of {@link DaffFilter}.
718
662
  *
719
663
  * @idempotent {filters}
720
664
  */
721
- declare const daffRemoveRequestFromFilters: (request: DaffFilterRequest, filters: DaffFilters) => DaffFilters;
722
-
665
+ export declare const daffRemoveRequestFromFilters: (request: DaffFilterRequest, filters: DaffFilters) => DaffFilters;
723
666
  /**
724
667
  * Undoes all applied options of a dictionary of {@link DaffFilter}
725
668
  * that match any of the {@link DaffFilterRequest},
@@ -727,269 +670,232 @@ declare const daffRemoveRequestFromFilters: (request: DaffFilterRequest, filters
727
670
  *
728
671
  * @idempotent {filters}
729
672
  */
730
- declare const daffRemoveRequestsFromFilters: (requests: (DaffFilterRequest)[], filters: DaffFilters) => DaffFilters;
731
-
673
+ export declare const daffRemoveRequestsFromFilters: (requests: (DaffFilterRequest)[], filters: DaffFilters) => DaffFilters;
732
674
  /**
733
675
  * Toggles the state of the filters (and their options) in the {@link DaffFilter}
734
676
  * that match the {@link DaffFilterToggleRequest} .
735
677
  */
736
- declare function daffToggleFilter(request: DaffFilterToggleRequest, filter: DaffFilter): DaffFilter;
737
-
678
+ export declare function daffToggleFilter(request: DaffFilterToggleRequest, filter: DaffFilter): DaffFilter;
738
679
  /**
739
680
  * Toggles the state of a filter option in the {@link DaffFilters}
740
681
  * that matches the {@link DaffFilterToggleRequest}.
741
682
  */
742
- declare const daffToggleRequestOnFilters: (request: DaffFilterToggleRequest, filters: DaffFilters) => DaffFilters;
743
-
683
+ export declare const daffToggleRequestOnFilters: (request: DaffFilterToggleRequest, filters: DaffFilters) => DaffFilters;
744
684
  /**
745
685
  * Determines whether or not a filter has any currently applied options.
746
686
  */
747
- declare const daffIsFilterApplied: (filter: DaffFilter) => boolean;
748
-
687
+ export declare const daffIsFilterApplied: (filter: DaffFilter) => boolean;
749
688
  /**
750
689
  * Determines whether or not a {@link DaffFilterToggleRequest} is already applied to a {@link DaffFilter}.
751
690
  */
752
- declare const daffIsToggleRequestAppliedToFilter: (request: DaffFilterToggleRequest, filter: DaffFilter) => boolean;
753
-
691
+ export declare const daffIsToggleRequestAppliedToFilter: (request: DaffFilterToggleRequest, filter: DaffFilter) => boolean;
754
692
  /**
755
693
  * Finds the applied options in the filter.
756
694
  */
757
- declare const daffFilterFindAppliedOptions: <T extends DaffFilterBase>(filter: T) => T["options"][string][];
758
-
695
+ export declare const daffFilterFindAppliedOptions: <T extends DaffFilterBase>(filter: T) => T["options"][string][];
759
696
  /**
760
697
  * Builds a filter request from a filter.
761
698
  * Returns null if the filter does not have at least one applied option.
762
699
  */
763
- declare function daffFilterToRequest(filter: DaffFilter): DaffFilterRequest | null;
764
-
700
+ export declare function daffFilterToRequest(filter: DaffFilter): DaffFilterRequest | null;
765
701
  /**
766
702
  * Builds a list of filter requests from a list of filters.
767
703
  * Requests are only built for the filters that have at least one applied option.
768
704
  */
769
- declare function daffFiltersToRequests(filters: DaffFilters): DaffFilterRequest[];
770
-
705
+ export declare function daffFiltersToRequests(filters: DaffFilters): DaffFilterRequest[];
771
706
  /**
772
707
  * Transforms an {@link DaffFilterRangePair[]} to a dictionary.
773
708
  */
774
- declare const daffFilterRangePairArrayToDict: <T>(pairs: DaffFilterRangePair<T>[]) => Record<string, DaffFilterRangePair<T>>;
775
-
776
- declare const daffFilterComputeRangePairLabel: (min: any, max: any) => string;
777
-
709
+ export declare const daffFilterRangePairArrayToDict: <T>(pairs: DaffFilterRangePair<T>[]) => Record<string, DaffFilterRangePair<T>>;
710
+ export declare const daffFilterComputeRangePairLabel: (min: any, max: any) => string;
778
711
  /**
779
712
  * Converts a list of equal filter options to a dict of options keyed by option value.
780
713
  */
781
- declare const daffFilterEqualOptionArrayToDict: (options: DaffFilterEqualOption[]) => Record<DaffFilterEqualOption["value"], DaffFilterEqualOption>;
782
-
714
+ export declare const daffFilterEqualOptionArrayToDict: (options: DaffFilterEqualOption[]) => Record<DaffFilterEqualOption["value"], DaffFilterEqualOption>;
783
715
  /**
784
716
  * Ensures that the names of the filter and the filter request match.
785
717
  *
786
718
  * @throws {@link DaffFilterNotFound} if the names do not match.
787
719
  */
788
- declare const daffFilterValidateRequestNameMatch: (request: DaffFilterRequest | DaffFilterToggleRequest, filter: DaffFilter) => void;
789
-
720
+ export declare const daffFilterValidateRequestNameMatch: (request: DaffFilterRequest | DaffFilterToggleRequest, filter: DaffFilter) => void;
790
721
  /**
791
722
  * Ensures that the types of the filter and the filter request match.
792
723
  *
793
724
  * @throws {@link DaffFilterRequestTypeMismatch} if the types do not match.
794
725
  */
795
- declare const daffFilterValidateRequestTypeMatch: (request: DaffFilterRequest | DaffFilterToggleRequest, filter: DaffFilter) => void;
796
-
726
+ export declare const daffFilterValidateRequestTypeMatch: (request: DaffFilterRequest | DaffFilterToggleRequest, filter: DaffFilter) => void;
797
727
  /**
798
728
  * An error thrown when a lookup for a filter.
799
729
  */
800
- declare class DaffFilterNotFound extends DaffInheritableError implements DaffError {
801
- readonly code: string;
802
- constructor(message?: string);
730
+ export declare class DaffFilterNotFound extends DaffInheritableError implements DaffError {
731
+ readonly code: string;
732
+ constructor(message?: string);
803
733
  }
804
-
805
734
  /**
806
735
  * An error thrown when an operation targeting a filter matching one type
807
736
  * matches a filter of another type.
808
737
  */
809
- declare class DaffFilterRequestTypeMismatch extends DaffInheritableError implements DaffError {
810
- readonly code: string;
811
- constructor(message?: string);
738
+ export declare class DaffFilterRequestTypeMismatch extends DaffInheritableError implements DaffError {
739
+ readonly code: string;
740
+ constructor(message?: string);
812
741
  }
813
-
814
742
  /**
815
743
  * An error thrown when an operation targeting a filter matching one name
816
744
  * matches a filter of another name.
817
745
  */
818
- declare class DaffFilterRequestNameMismatch extends DaffInheritableError implements DaffError {
819
- readonly code: string;
820
- constructor(message?: string);
746
+ export declare class DaffFilterRequestNameMismatch extends DaffInheritableError implements DaffError {
747
+ readonly code: string;
748
+ constructor(message?: string);
821
749
  }
822
-
823
750
  /**
824
751
  * An error thrown when an operation targeting a filter matches a type unknown
825
752
  * to Daffodil.
826
753
  */
827
- declare class DaffFilterUnknownType extends DaffInheritableError implements DaffError {
828
- readonly code: string;
829
- constructor(message?: string);
754
+ export declare class DaffFilterUnknownType extends DaffInheritableError implements DaffError {
755
+ readonly code: string;
756
+ constructor(message?: string);
830
757
  }
831
-
832
758
  /**
833
759
  * Converts a list of filters into a dictionary of filters keyed by filter name.
834
760
  */
835
- declare const daffFilterArrayToDict: <T extends DaffFilter = DaffFilter>(filters: Array<T>) => DaffFilters<T>;
836
-
761
+ export declare const daffFilterArrayToDict: <T extends DaffFilter = DaffFilter>(filters: Array<T>) => DaffFilters<T>;
837
762
  /**
838
763
  * Returns a {@link DaffFilters} and only their applied options.
839
764
  * {@link DaffFilter} that have no applied options will be omitted.
840
765
  */
841
- declare const daffComputeAppliedFilters: (filters: DaffFilters) => DaffFilters;
842
-
766
+ export declare const daffComputeAppliedFilters: (filters: DaffFilters) => DaffFilters;
843
767
  /**
844
768
  * A injection token to hold and provide a single value.
845
769
  */
846
- interface DaffSingleInjectionToken<T = unknown> {
847
- /**
848
- * The injection token.
849
- */
850
- token: InjectionToken<T>;
851
- /**
852
- * A helper function to provide a value to the token.
853
- */
854
- provider: <R extends T = T>(value: R) => ValueProvider;
855
- /**
856
- * A helper function to provide factories to the token.
857
- */
858
- factoryProvider: <R extends T = T>(factory: () => R) => FactoryProvider;
770
+ export interface DaffSingleInjectionToken<T = unknown> {
771
+ /**
772
+ * The injection token.
773
+ */
774
+ token: InjectionToken<T>;
775
+ /**
776
+ * A helper function to provide a value to the token.
777
+ */
778
+ provider: <R extends T = T>(value: R) => ValueProvider;
779
+ /**
780
+ * A helper function to provide factories to the token.
781
+ */
782
+ factoryProvider: <R extends T = T>(factory: () => R) => FactoryProvider;
859
783
  }
860
-
861
784
  type TokenDesc<T> = ConstructorParameters<typeof InjectionToken<T>>[0];
862
785
  type TokenOptions<T> = ConstructorParameters<typeof InjectionToken<T>>[1];
863
-
864
786
  /**
865
787
  * Creates an injection token/provider pair for a single valued DI token.
866
788
  *
867
789
  * See {@link DaffSingleInjectionToken}.
868
790
  */
869
- declare const createSingleInjectionToken: <T = unknown>(desc: TokenDesc<T>, options?: TokenOptions<T>) => DaffSingleInjectionToken<T>;
870
-
791
+ export declare const createSingleInjectionToken: <T = unknown>(desc: TokenDesc<T>, options?: TokenOptions<T>) => DaffSingleInjectionToken<T>;
871
792
  /**
872
793
  * A injection token to hold and provide multiple values.
873
794
  */
874
- interface DaffMultiInjectionToken<T = unknown> {
875
- /**
876
- * The injection token.
877
- * Its default value is an empty array.
878
- */
879
- token: InjectionToken<Array<T>>;
880
- /**
881
- * A helper function to provide values to the token.
882
- */
883
- provider: <R extends T = T>(...values: Array<R>) => Array<ValueProvider>;
884
- /**
885
- * A helper function to provide factories to the token.
886
- */
887
- factoryProvider: <R extends T = T>(...factories: Array<() => R>) => Array<FactoryProvider>;
795
+ export interface DaffMultiInjectionToken<T = unknown> {
796
+ /**
797
+ * The injection token.
798
+ * Its default value is an empty array.
799
+ */
800
+ token: InjectionToken<Array<T>>;
801
+ /**
802
+ * A helper function to provide values to the token.
803
+ */
804
+ provider: <R extends T = T>(...values: Array<R>) => Array<ValueProvider>;
805
+ /**
806
+ * A helper function to provide factories to the token.
807
+ */
808
+ factoryProvider: <R extends T = T>(...factories: Array<() => R>) => Array<FactoryProvider>;
888
809
  }
889
-
890
810
  /**
891
811
  * Creates an injection token/provider pair for a multi valued DI token.
892
812
  *
893
813
  * See {@link DaffMultiInjectionToken}.
894
814
  */
895
- declare const createMultiInjectionToken: <T = unknown>(desc: TokenDesc<Array<T>>, options?: Partial<TokenOptions<Array<T>>>) => DaffMultiInjectionToken<T>;
896
-
815
+ export declare const createMultiInjectionToken: <T = unknown>(desc: TokenDesc<Array<T>>, options?: Partial<TokenOptions<Array<T>>>) => DaffMultiInjectionToken<T>;
897
816
  /**
898
817
  * A injection token to hold and provide a config value.
899
818
  */
900
- interface DaffConfigInjectionToken<T = unknown> {
901
- /**
902
- * The injection token.
903
- * Its default value is the default config passed during token creation.
904
- */
905
- token: InjectionToken<T>;
906
- /**
907
- * A helper function to provide a value to the token.
908
- * It will shallow merge the passed config with the default config
909
- * with the passed config keys taking precedence.
910
- * An injection token containing a config may also be passed.
911
- */
912
- provider: <R extends T = T>(config: Partial<R> | InjectionToken<Partial<R>>) => FactoryProvider;
819
+ export interface DaffConfigInjectionToken<T = unknown> {
820
+ /**
821
+ * The injection token.
822
+ * Its default value is the default config passed during token creation.
823
+ */
824
+ token: InjectionToken<T>;
825
+ /**
826
+ * A helper function to provide a value to the token.
827
+ * It will shallow merge the passed config with the default config
828
+ * with the passed config keys taking precedence.
829
+ * An injection token containing a config may also be passed.
830
+ */
831
+ provider: <R extends T = T>(config: Partial<R> | InjectionToken<Partial<R>>) => FactoryProvider;
913
832
  }
914
-
915
833
  /**
916
834
  * Creates an injection token/provider pair for a DI token that holds a configuration.
917
835
  *
918
836
  * See {@link DaffConfigInjectionToken}.
919
837
  */
920
- declare const createConfigInjectionToken: <T = unknown>(defaultConfig: T | InjectionToken<T>, desc: TokenDesc<T>, options?: Partial<TokenOptions<T>>) => DaffConfigInjectionToken<T>;
921
-
838
+ export declare const createConfigInjectionToken: <T = unknown>(defaultConfig: T | InjectionToken<T>, desc: TokenDesc<T>, options?: Partial<TokenOptions<T>>) => DaffConfigInjectionToken<T>;
922
839
  /**
923
840
  * A injection token to hold and provide multiple services.
924
841
  */
925
- interface DaffServicesInjectionToken<T = unknown> {
926
- /**
927
- * The injection token.
928
- * Its default value is an empty array.
929
- */
930
- token: InjectionToken<Array<T>>;
931
- /**
932
- * A helper function to provide service classes to the token.
933
- */
934
- provider: <R extends T = T>(...classes: Array<Type<R>>) => Array<ExistingProvider>;
842
+ export interface DaffServicesInjectionToken<T = unknown> {
843
+ /**
844
+ * The injection token.
845
+ * Its default value is an empty array.
846
+ */
847
+ token: InjectionToken<Array<T>>;
848
+ /**
849
+ * A helper function to provide service classes to the token.
850
+ */
851
+ provider: <R extends T = T>(...classes: Array<Type<R>>) => Array<ExistingProvider>;
935
852
  }
936
-
937
853
  /**
938
854
  * Creates an injection token/provider pair for a DI token that holds services.
939
855
  *
940
856
  * See {@link DaffServicesInjectionToken}.
941
857
  */
942
- declare const createServicesInjectionToken: <T = unknown>(desc: TokenDesc<Array<T>>, options?: Partial<TokenOptions<Array<T>>>) => DaffServicesInjectionToken<T>;
943
-
858
+ export declare const createServicesInjectionToken: <T = unknown>(desc: TokenDesc<Array<T>>, options?: Partial<TokenOptions<Array<T>>>) => DaffServicesInjectionToken<T>;
944
859
  /**
945
860
  * A injection token to hold and provide a singleton service.
946
861
  */
947
- interface DaffSingletonInjectionToken<T = unknown> {
948
- /**
949
- * The injection token.
950
- * Its default value is an empty array.
951
- */
952
- token: InjectionToken<T>;
953
- /**
954
- * A helper function to provide the service class to the token.
955
- */
956
- provider: <R extends T = T>(klass: Type<R>) => ExistingProvider;
862
+ export interface DaffSingletonInjectionToken<T = unknown> {
863
+ /**
864
+ * The injection token.
865
+ * Its default value is an empty array.
866
+ */
867
+ token: InjectionToken<T>;
868
+ /**
869
+ * A helper function to provide the service class to the token.
870
+ */
871
+ provider: <R extends T = T>(klass: Type<R>) => ExistingProvider;
957
872
  }
958
-
959
873
  /**
960
874
  * Creates an injection token/provider pair for a DI token that holds a singleton service.
961
875
  *
962
876
  * See {@link DaffSingletonInjectionToken}.
963
877
  */
964
- declare const createSingletonInjectionToken: <T = unknown>(desc: TokenDesc<T>, options?: TokenOptions<T>) => DaffSingletonInjectionToken<T>;
965
-
878
+ export declare const createSingletonInjectionToken: <T = unknown>(desc: TokenDesc<T>, options?: TokenOptions<T>) => DaffSingletonInjectionToken<T>;
966
879
  /**
967
880
  * An object with a discrete kind.
968
881
  */
969
- interface DaffKindable<T extends string = string> {
970
- /**
971
- * The entity kind.
972
- */
973
- kind: T;
882
+ export interface DaffKindable<T extends string = string> {
883
+ /**
884
+ * The entity kind.
885
+ */
886
+ kind: T;
974
887
  }
975
-
976
- declare function daffArrayConcatMerger<T extends Array<unknown> = Array<unknown>>(a: T, b: T): T;
977
-
978
- declare function daffDictAssignMerger<T extends Record<string, unknown> = Record<string, unknown>>(a: T, b: T): T;
979
-
888
+ export declare function daffArrayConcatMerger<T extends Array<unknown> = Array<unknown>>(a: T, b: T): T;
889
+ export declare function daffDictAssignMerger<T extends Record<string, unknown> = Record<string, unknown>>(a: T, b: T): T;
980
890
  /**
981
891
  * A way to merge two fields into one.
982
892
  */
983
- type DaffMerger<T> = (a: T, b: T) => T;
984
-
893
+ export type DaffMerger<T> = (a: T, b: T) => T;
985
894
  /**
986
895
  * A strategy for merging objects of the same structure.
987
896
  * Each key can contain a merger function for handling collisions.
988
897
  */
989
- type DaffMergeStrategy<T extends Record<string, unknown> = Record<string, unknown>> = {
990
- [k in keyof T]?: DaffMerger<T[k]>;
991
- };
992
-
898
+ export type DaffMergeStrategy<T extends Record<string, unknown> = Record<string, unknown>> = { [k in keyof T]?: DaffMerger<T[k]>; };
993
899
  /**
994
900
  * Merges dictionaries with a specific strategy for handling collisions.
995
901
  * @see {@link DaffMergeStrategy}.
@@ -1052,155 +958,141 @@ type DaffMergeStrategy<T extends Record<string, unknown> = Record<string, unknow
1052
958
  * }
1053
959
  * ```
1054
960
  */
1055
- declare const daffMerge: <T extends Record<string, unknown> = Record<string, unknown>>(dicts: Array<T>, strategy?: DaffMergeStrategy<T>) => T;
1056
-
961
+ export declare const daffMerge: <T extends Record<string, unknown> = Record<string, unknown>>(dicts: Array<T>, strategy?: DaffMergeStrategy<T>) => T;
1057
962
  /**
1058
963
  * Retries failed Observables
1059
964
  *
1060
965
  * @param maxTries The maximum number of tries the observable will be tried
1061
966
  * @param ms The initial amount of time
1062
967
  */
1063
- declare function backoff(maxTries: number, ms: number): rxjs.UnaryFunction<rxjs.Observable<unknown>, rxjs.Observable<unknown>>;
1064
-
968
+ export declare function backoff(maxTries: number, ms: number): import("rxjs").UnaryFunction<import("rxjs").Observable<unknown>, import("rxjs").Observable<unknown>>;
1065
969
  /**
1066
970
  * Accepts a list of input observables and emits true when any of the inputs emit a truthy value.
1067
971
  * Does not emit until all of the input streams have emitted at least once.
1068
972
  */
1069
- declare const anyOf: (items: Observable<boolean>[]) => Observable<boolean>;
1070
-
973
+ export declare const anyOf: (items: Observable<boolean>[]) => Observable<boolean>;
1071
974
  /**
1072
975
  * Accepts a list of input observables and emits true when all of the inputs emit a truthy value.
1073
976
  * Does not emit until all of the input streams have emitted at least once.
1074
977
  */
1075
- declare const allOf: (items: Observable<boolean>[]) => Observable<boolean>;
1076
-
978
+ export declare const allOf: (items: Observable<boolean>[]) => Observable<boolean>;
1077
979
  /**
1078
980
  * Catches errors and invokes the callback with an array of errors.
1079
981
  */
1080
- declare const catchAndArrayifyErrors: <TReturn, TError extends DaffError = DaffError>(transformError: (errors: TError[]) => Observable<TReturn>) => rxjs.UnaryFunction<Observable<unknown>, Observable<TReturn>>;
1081
-
1082
- declare const DAFF_STORAGE_SERVICE_ERROR_CODE = "DAFF_STORAGE_FAILURE";
1083
- declare class DaffStorageServiceError extends DaffInheritableError implements DaffError {
1084
- message: string;
1085
- readonly code: string;
1086
- constructor(message: string);
982
+ export declare const catchAndArrayifyErrors: <TReturn, TError extends DaffError = DaffError>(transformError: (errors: TError[]) => Observable<TReturn>) => import("rxjs").UnaryFunction<Observable<unknown>, Observable<TReturn>>;
983
+ export declare const DAFF_STORAGE_SERVICE_ERROR_CODE = "DAFF_STORAGE_FAILURE";
984
+ export declare class DaffStorageServiceError extends DaffInheritableError implements DaffError {
985
+ message: string;
986
+ readonly code: string;
987
+ constructor(message: string);
1087
988
  }
1088
-
1089
- interface DaffPersistenceService {
1090
- setItem(key: string, value: any): void;
1091
- getItem(key: string): any;
1092
- clear(): void;
1093
- removeItem(key: string): void;
989
+ export interface DaffPersistenceService {
990
+ setItem(key: string, value: any): void;
991
+ getItem(key: string): any;
992
+ clear(): void;
993
+ removeItem(key: string): void;
1094
994
  }
1095
- declare const DaffPersistenceServiceToken: i0.InjectionToken<DaffPersistenceService>;
1096
-
995
+ declare const DaffPersistenceServiceToken: import("@angular/core").InjectionToken<DaffPersistenceService>, provideDaffPersistenceService: <R extends DaffPersistenceService = DaffPersistenceService>(value: R) => import("@angular/core").ValueProvider;
1097
996
  /**
1098
997
  * @inheritdoc
1099
998
  */
1100
- declare class DaffErrorStorageService implements DaffPersistenceService {
1101
- static readonly ERROR_MESSAGE = "The DaffErrorStorageService always throws an error.";
1102
- setItem(key: string, value: any): void;
1103
- getItem(key: string): any;
1104
- removeItem(key: string): any;
1105
- clear(): void;
1106
- private throwError;
1107
- static ɵfac: i0.ɵɵFactoryDeclaration<DaffErrorStorageService, never>;
1108
- static ɵprov: i0.ɵɵInjectableDeclaration<DaffErrorStorageService>;
999
+ export declare class DaffErrorStorageService implements DaffPersistenceService {
1000
+ static readonly ERROR_MESSAGE = "The DaffErrorStorageService always throws an error.";
1001
+ setItem(key: string, value: any): void;
1002
+ getItem(key: string): any;
1003
+ removeItem(key: string): any;
1004
+ clear(): void;
1005
+ private throwError;
1006
+ static ɵfac: i0.ɵɵFactoryDeclaration<DaffErrorStorageService, never>;
1007
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
1109
1008
  }
1110
-
1111
- declare const DAFF_SERVER_STORAGE_SERVICE_ERROR_CODE = "DAFF_SERVER_STORAGE_FAILURE";
1009
+ export declare const DAFF_SERVER_STORAGE_SERVICE_ERROR_CODE = "DAFF_SERVER_STORAGE_FAILURE";
1112
1010
  /**
1113
1011
  * An error thrown when there is an attempt to access storage on the server and none is available.
1114
1012
  */
1115
- declare class DaffServerSideStorageError extends DaffStorageServiceError implements DaffError {
1116
- message: string;
1117
- readonly code: string;
1118
- constructor(message: string);
1013
+ export declare class DaffServerSideStorageError extends DaffStorageServiceError implements DaffError {
1014
+ message: string;
1015
+ readonly code: string;
1016
+ constructor(message: string);
1119
1017
  }
1120
-
1121
1018
  /**
1122
1019
  * A storage service meant to be loaded into SSR contexts.
1123
1020
  * It will always throw the {@link DaffServerSideStorageError}.
1124
1021
  *
1125
1022
  * @inheritdoc
1126
1023
  */
1127
- declare class DaffServerErrorStorageService implements DaffPersistenceService {
1128
- static readonly ERROR_MESSAGE = "The DaffServerErrorStorageService always throws an error.";
1129
- setItem(key: string, value: any): void;
1130
- getItem(key: string): any;
1131
- removeItem(key: string): any;
1132
- clear(): void;
1133
- private throwError;
1134
- static ɵfac: i0.ɵɵFactoryDeclaration<DaffServerErrorStorageService, never>;
1135
- static ɵprov: i0.ɵɵInjectableDeclaration<DaffServerErrorStorageService>;
1024
+ export declare class DaffServerErrorStorageService implements DaffPersistenceService {
1025
+ static readonly ERROR_MESSAGE = "The DaffServerErrorStorageService always throws an error.";
1026
+ setItem(key: string, value: any): void;
1027
+ getItem(key: string): any;
1028
+ removeItem(key: string): any;
1029
+ clear(): void;
1030
+ private throwError;
1031
+ static ɵfac: i0.ɵɵFactoryDeclaration<DaffServerErrorStorageService, never>;
1032
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
1136
1033
  }
1137
-
1138
1034
  /**
1139
1035
  * @inheritdoc
1140
1036
  */
1141
- declare class DaffLocalStorageService implements DaffPersistenceService {
1142
- constructor(platformId: string);
1143
- /**
1144
- * Persist the given item into local storage.
1145
- */
1146
- setItem(key: string, value: any): void;
1147
- /**
1148
- * Retrieve the given item from localstorage.
1149
- */
1150
- getItem(key: string): any;
1151
- /**
1152
- * Remove a given item from localstorage
1153
- */
1154
- removeItem(key: string): any;
1155
- clear(): void;
1156
- static ɵfac: i0.ɵɵFactoryDeclaration<DaffLocalStorageService, never>;
1157
- static ɵprov: i0.ɵɵInjectableDeclaration<DaffLocalStorageService>;
1037
+ export declare class DaffLocalStorageService implements DaffPersistenceService {
1038
+ constructor(platformId: string);
1039
+ /**
1040
+ * Persist the given item into local storage.
1041
+ */
1042
+ setItem(key: string, value: any): void;
1043
+ /**
1044
+ * Retrieve the given item from localstorage.
1045
+ */
1046
+ getItem(key: string): any;
1047
+ /**
1048
+ * Remove a given item from localstorage
1049
+ */
1050
+ removeItem(key: string): any;
1051
+ clear(): void;
1052
+ static ɵfac: i0.ɵɵFactoryDeclaration<DaffLocalStorageService, never>;
1053
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
1158
1054
  }
1159
-
1160
1055
  /**
1161
1056
  * @inheritdoc
1162
1057
  */
1163
- declare class DaffNoopStorageService implements DaffPersistenceService {
1164
- setItem(key: string, value: any): void;
1165
- getItem(key: string): any;
1166
- clear(): void;
1167
- removeItem(key: string): void;
1168
- static ɵfac: i0.ɵɵFactoryDeclaration<DaffNoopStorageService, never>;
1169
- static ɵprov: i0.ɵɵInjectableDeclaration<DaffNoopStorageService>;
1058
+ export declare class DaffNoopStorageService implements DaffPersistenceService {
1059
+ setItem(key: string, value: any): void;
1060
+ getItem(key: string): any;
1061
+ clear(): void;
1062
+ removeItem(key: string): void;
1063
+ static ɵfac: i0.ɵɵFactoryDeclaration<DaffNoopStorageService, never>;
1064
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
1170
1065
  }
1171
-
1172
1066
  /**
1173
1067
  * @inheritdoc
1174
1068
  */
1175
- declare class DaffMemoryStorageService implements DaffPersistenceService {
1176
- memory: {
1177
- [x: string]: any;
1178
- };
1179
- setItem(key: string, value: any): void;
1180
- getItem(key: string): any;
1181
- clear(): void;
1182
- /**
1183
- * We abuse destructuring to remove the key
1184
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment
1185
- */
1186
- removeItem(key: string): void;
1069
+ export declare class DaffMemoryStorageService implements DaffPersistenceService {
1070
+ memory: {
1071
+ [x: string]: any;
1072
+ };
1073
+ setItem(key: string, value: any): void;
1074
+ getItem(key: string): any;
1075
+ clear(): void;
1076
+ /**
1077
+ * We abuse destructuring to remove the key
1078
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment
1079
+ */
1080
+ removeItem(key: string): void;
1081
+ static ɵfac: i0.ɵɵFactoryDeclaration<DaffMemoryStorageService, never>;
1082
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
1187
1083
  }
1188
-
1189
- declare const DaffServerSafePersistenceServiceToken: i0.InjectionToken<DaffPersistenceService>;
1190
-
1084
+ declare const DaffServerSafePersistenceServiceToken: import("@angular/core").InjectionToken<DaffPersistenceService>, provideDaffServerSafePersistenceServiceToken: <R extends DaffPersistenceService = DaffPersistenceService>(value: R) => import("@angular/core").ValueProvider;
1191
1085
  /**
1192
1086
  * A token type for HTML.
1193
1087
  * A string that holds renderable content that is suitable for rendering with `[innerHTML]`.
1194
1088
  */
1195
- type HTML = string;
1196
-
1089
+ export type HTML = string;
1197
1090
  /**
1198
1091
  * Recurses through a tree, collecting each element in that tree and returning it in an array.
1199
1092
  * The value of getKey should be a field that contains a list of the same type of object.
1200
1093
  * Accepts an optional depth argument which will limit the traversal. This should be used for trees with circular references.
1201
1094
  */
1202
- declare const collect: <T>(obj: T, getChildren: (val: T) => T[], depth?: number) => T[];
1203
-
1095
+ export declare const collect: <T>(obj: T, getChildren: (val: T) => T[], depth?: number) => T[];
1204
1096
  /**
1205
1097
  * A helper function to compute a power of 10 required to convert a decimal number to an integer
1206
1098
  * This function will fail if the given number has more than 16 significant figures or
@@ -1208,7 +1100,7 @@ declare const collect: <T>(obj: T, getChildren: (val: T) => T[], depth?: number)
1208
1100
  *
1209
1101
  * @param value
1210
1102
  */
1211
- declare function daffPrecision(value: number): number;
1103
+ export declare function daffPrecision(value: number): number;
1212
1104
  /**
1213
1105
  * A function to add long numbers accurately with conversions and integer math.
1214
1106
  * This function only guarantees correct answers when the numbers given and the result are less than
@@ -1216,7 +1108,7 @@ declare function daffPrecision(value: number): number;
1216
1108
  *
1217
1109
  * @param numbers
1218
1110
  */
1219
- declare function daffAdd(...numbers: number[]): number;
1111
+ export declare function daffAdd(...numbers: number[]): number;
1220
1112
  /**
1221
1113
  * A function to subtract long numbers accurately with conversions and integer math.
1222
1114
  * This function only guarantees correct answers when the numbers given and the result are each less than
@@ -1224,7 +1116,7 @@ declare function daffAdd(...numbers: number[]): number;
1224
1116
  *
1225
1117
  * @param numbers
1226
1118
  */
1227
- declare function daffSubtract(...numbers: number[]): number;
1119
+ export declare function daffSubtract(...numbers: number[]): number;
1228
1120
  /**
1229
1121
  * A function to multiply long numbers accurately with conversions and integer math.
1230
1122
  * This function only guarantees correct answers when the numbers given and the result are each less than 16 significant figures
@@ -1232,7 +1124,7 @@ declare function daffSubtract(...numbers: number[]): number;
1232
1124
  *
1233
1125
  * @param numbers
1234
1126
  */
1235
- declare function daffMultiply(...numbers: number[]): number;
1127
+ export declare function daffMultiply(...numbers: number[]): number;
1236
1128
  /**
1237
1129
  * A function to divide long numbers accurately with conversions and integer math.
1238
1130
  * This function only guarantees correct answers when the numbers given and the result are each less than 16 significant figures
@@ -1243,31 +1135,27 @@ declare function daffMultiply(...numbers: number[]): number;
1243
1135
  *
1244
1136
  * @param numbers
1245
1137
  */
1246
- declare function daffDivide(...numbers: number[]): number;
1247
-
1138
+ export declare function daffDivide(...numbers: number[]): number;
1248
1139
  type Dictionary = Record<string | number | symbol, any>;
1249
1140
  /**
1250
1141
  * Converts an array into a dictionary.
1251
1142
  * Dictionary values are keyed by the return of the specified `getKey`.
1252
1143
  */
1253
- declare const daffArrayToDict: <T, R extends keyof Dictionary = keyof Dictionary>(array: Array<T>, getKey: (val: T) => R) => Record<R, T>;
1254
-
1144
+ export declare const daffArrayToDict: <T, R extends keyof Dictionary = keyof Dictionary>(array: Array<T>, getKey: (val: T) => R) => Record<R, T>;
1255
1145
  /**
1256
1146
  * Returns a random slice of an array.
1257
1147
  * An optional length may be specified.
1258
1148
  *
1259
1149
  * @param array
1260
1150
  */
1261
- declare const randomSlice: <T>(array: T[], length?: number) => T[];
1262
-
1151
+ export declare const randomSlice: <T>(array: T[], length?: number) => T[];
1263
1152
  /**
1264
1153
  * Returns a random subset of an array in a random order.
1265
1154
  *
1266
1155
  * @param array
1267
1156
  * @param length
1268
1157
  */
1269
- declare const randomSubset: <T>(array: T[], length?: number) => T[];
1270
-
1158
+ export declare const randomSubset: <T>(array: T[], length?: number) => T[];
1271
1159
  /**
1272
1160
  * Range
1273
1161
  *
@@ -1279,26 +1167,22 @@ declare const randomSubset: <T>(array: T[], length?: number) => T[];
1279
1167
  * @param end
1280
1168
  * @returns number
1281
1169
  */
1282
- declare const range: (start: number, end: number) => Array<number>;
1283
-
1170
+ export declare const range: (start: number, end: number) => Array<number>;
1284
1171
  /**
1285
1172
  * Returns a random element of an array.
1286
1173
  */
1287
- declare const sample: <T>(array: T[]) => T;
1288
-
1174
+ export declare const sample: <T>(array: T[]) => T;
1289
1175
  /**
1290
1176
  * Shallow compares two objects using a list of provided property keys to enumerate the values.
1291
1177
  * `null` and `undefined` are considered equal for the purposes of the comparison.
1292
1178
  * A strict equality comparison is used for truthy property values.
1293
1179
  */
1294
- declare function shallowCompare<T>(obj1: T, obj2: T, props: (T extends T ? keyof T : never)[]): boolean;
1295
-
1180
+ export declare function shallowCompare<T>(obj1: T, obj2: T, props: (T extends T ? keyof T : never)[]): boolean;
1296
1181
  /**
1297
1182
  * Immutable Fisher-Yates Shuffle
1298
1183
  * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
1299
1184
  */
1300
- declare const shuffle: <T>(array: T[]) => T[];
1301
-
1185
+ export declare const shuffle: <T>(array: T[]) => T[];
1302
1186
  /**
1303
1187
  * Filters an array of elements, removing duplicates.
1304
1188
  * Does not guarantee order of filtered elements.
@@ -1306,40 +1190,33 @@ declare const shuffle: <T>(array: T[]) => T[];
1306
1190
  * An optional comparator function may be passed for arbitrary comparison behavior.
1307
1191
  * The default is a strict equality comparison: `a === b`.
1308
1192
  */
1309
- declare const unique: <T>(array: T[], comparator?: (a: T, b: T) => boolean) => T[];
1310
-
1193
+ export declare const unique: <T>(array: T[], comparator?: (a: T, b: T) => boolean) => T[];
1311
1194
  /**
1312
1195
  * The unary identity function.
1313
1196
  * Returns whatever is passed to it.
1314
1197
  */
1315
- declare function identity<T>(v: T): T;
1316
-
1317
- type MaybeAsync<T> = Promise<T> | Observable<T> | T;
1318
-
1198
+ export declare function identity<T>(v: T): T;
1199
+ export type MaybeAsync<T> = Promise<T> | Observable<T> | T;
1319
1200
  /**
1320
1201
  * Converts a value to an observable.
1321
1202
  * If the value is an observable, just returns that observable.
1322
1203
  * If the value is a promise, converts it to an observable (see rxjs `from`).
1323
1204
  * If the value is neither, just returns an observable that immediately emits the value.
1324
1205
  */
1325
- declare function observe<T>(val: MaybeAsync<T>): Observable<T>;
1326
-
1206
+ export declare function observe<T>(val: MaybeAsync<T>): Observable<T>;
1327
1207
  /**
1328
1208
  * Validates whether all the specified fields are defined in the passed object.
1329
1209
  * Uses `Object.hasOwn` to do the check, so even if a field has been set to `null`
1330
1210
  * or `undefined`, they will be treated as present.
1331
1211
  */
1332
- declare const validateFieldPresence: <T extends Record<string, unknown>>(model: T, ...fields: Array<keyof T>) => boolean;
1333
-
1212
+ export declare const validateFieldPresence: <T extends Record<string, unknown>>(model: T, ...fields: Array<keyof T>) => boolean;
1334
1213
  /**
1335
1214
  * An interface for models where the order of elements is important
1336
1215
  * and definable.
1337
1216
  *
1338
1217
  * Disambiguation: This is does not relate to ecommerce "Orders", e.g. a purchase.
1339
1218
  */
1340
- interface DaffOrderable {
1341
- order: number;
1219
+ export interface DaffOrderable {
1220
+ order: number;
1342
1221
  }
1343
-
1344
- export { DAFF_COLLECTION_PAGE_OUT_OF_BOUNDS_ERROR_CODE, DAFF_SERVER_STORAGE_SERVICE_ERROR_CODE, DAFF_STORAGE_SERVICE_ERROR_CODE, DaffBase64ServiceToken, DaffBrowserBase64Service, DaffCollectionPageOutOfBoundsError, DaffErrorStorageService, DaffFilterFromToFilterSeparator, DaffFilterNotFound, DaffFilterRequestNameMismatch, DaffFilterRequestTypeMismatch, DaffFilterType, DaffFilterUnknownType, DaffInheritableError, DaffLocalStorageService, DaffMemoryStorageService, DaffNoopStorageService, DaffPersistenceServiceToken, DaffServerBase64Service, DaffServerErrorStorageService, DaffServerSafePersistenceServiceToken, DaffServerSideStorageError, DaffSortDirectionEnum, DaffStorageServiceError, allOf, anyOf, backoff, catchAndArrayifyErrors, collect, createConfigInjectionToken, createMultiInjectionToken, createServicesInjectionToken, createSingleInjectionToken, createSingletonInjectionToken, daffAdd, daffApplyFilter, daffApplyRequestToFilters, daffApplyRequestsToFilters, daffArrayConcatMerger, daffArrayToDict, daffClearFilter, daffClearFilters, daffCollectionBuildMetadataFromRequest, daffCollectionBuildRequestFromMetadata, daffCollectionErrorMap, daffComputeAppliedFilters, daffCreateableMostRecent, daffDictAssignMerger, daffDivide, daffFilterArrayToDict, daffFilterComputeRangePairLabel, daffFilterEqualOptionArrayToDict, daffFilterFindAppliedOptions, daffFilterRangePairArrayToDict, daffFilterToRequest, daffFilterValidateRequestNameMatch, daffFilterValidateRequestTypeMatch, daffFiltersToRequests, daffIdentifiableArrayToDict, daffIsError, daffIsFilterApplied, daffIsToggleRequestAppliedToFilter, daffMerge, daffMultiply, daffPrecision, daffRemoveFilter, daffRemoveRequestFromFilters, daffRemoveRequestsFromFilters, daffSubtract, daffToggleFilter, daffToggleRequestOnFilters, debounce, identity, observe, provideVercelImageLoader, randomSlice, randomSubset, range, sample, shallowCompare, shuffle, unique, validateFieldPresence };
1345
- export type { Constructable, DaffBase64Service, DaffCanonicallyLocatable, DaffCollection, DaffCollectionMetadata, DaffCollectionRequest, DaffConfigInjectionToken, DaffCountable, DaffCreateable, DaffError, DaffErrorCodeMap, DaffFilter, DaffFilterBase, DaffFilterEqual, DaffFilterEqualOption, DaffFilterEqualRequest, DaffFilterEqualToggleRequest, DaffFilterOption, DaffFilterOptionBase, DaffFilterRangeBase, DaffFilterRangeNumeric, DaffFilterRangeNumericRequest, DaffFilterRangeNumericToggleRequest, DaffFilterRangeOption, DaffFilterRangePair, DaffFilterRangeRequestBase, DaffFilterRangeRequestOption, DaffFilterRequest, DaffFilterToggleRequest, DaffFilterable, DaffFilters, DaffIdentifiable, DaffKindable, DaffLocatable, DaffMergeStrategy, DaffMerger, DaffMultiInjectionToken, DaffNumericallyPaginable, DaffOrderable, DaffPersistenceService, DaffServicesInjectionToken, DaffSingleInjectionToken, DaffSingletonInjectionToken, DaffSortOption, DaffSortOptions, DaffSortable, HTML, ID, MaybeAsync };
1222
+ export { DaffBase64ServiceToken, DaffPersistenceServiceToken, DaffServerSafePersistenceServiceToken };