@dcupl/common 0.0.72 → 0.0.74

package/dist/lib-esm/types/data.types.d.ts

@@ -1,14 +1,14 @@
-export declare type RawItem = any;
-export declare type ListItem = {
+export type RawItem = any;
+export type ListItem = {
     key: string;
     [id: string]: any;
 };
-export declare type DataContainer<ListType extends RawItem | ListItem = ListItem, ModelNames extends string = string> = {
+export type DataContainer<ListType extends RawItem | ListItem = ListItem, ModelNames extends string = string> = {
     model: ModelNames;
     type?: DataContainerType;
     data: ListType[];
     keyProperty?: string;
     autoGenerateKey?: boolean;
 };
-export declare type DataContainerType = 'upsert' | 'update' | 'set' | 'delete';
-export declare type ReferenceDataTypes<ListType extends ListItem = ListItem> = string | string[] | ListType | ListType[];
+export type DataContainerType = 'upsert' | 'update' | 'set' | 'delete';
+export type ReferenceDataTypes<ListType extends ListItem = ListItem> = string | string[] | ListType | ListType[];

package/dist/lib-esm/types/dcupl.types.d.ts

@@ -1,31 +1,31 @@
 import { FilterOptions } from './filter.types';
 import { DcuplItemOptions, DcuplItemsOptions } from './list.types';
-export declare type DcuplInitOptions = {
+export type DcuplInitOptions = {
     config?: DcuplInitConfig;
     logs?: DcuplInitLoggingConfig;
     errorTracking?: DcuplInitErrorTrackingConfig;
     selection?: DcuplSelectionConfig;
 };
-export declare type DcuplInitErrorTrackingConfig = {
+export type DcuplInitErrorTrackingConfig = {
     enabled: boolean;
 };
-export declare type DcuplSelectionConfig = {
+export type DcuplSelectionConfig = {
     baseUrl: string;
 };
-export declare type DcuplInitLoggingConfig = {
+export type DcuplInitLoggingConfig = {
     enabled: boolean;
 };
-export declare type DcuplInitConfig = {
+export type DcuplInitConfig = {
     projectId?: string;
     apiKey?: string;
     version?: string;
 };
-export declare type DcuplErrorResponse = {
+export type DcuplErrorResponse = {
     name?: string;
     message?: string;
     type?: 'fatal' | 'minor';
 };
-export declare type DcuplMetrics = {
+export type DcuplMetrics = {
     total?: number;
     core?: number;
 };
@@ -33,20 +33,20 @@ export interface DcuplFunction {
     name: string;
     args: Array<any>;
 }
-export declare type DcuplResponse<T> = {
+export type DcuplResponse<T> = {
     id?: string;
     func: DcuplFunction;
     result?: T;
     error?: DcuplErrorResponse;
     metrics: DcuplMetrics;
 };
-export declare type DcuplGlobalItemsOptions<T> = DcuplItemsOptions<T> & {
+export type DcuplGlobalItemsOptions<T> = DcuplItemsOptions<T> & {
     listKey: string;
 };
-export declare type DcuplGlobalItemOptions<T> = DcuplItemOptions<T> & {
+export type DcuplGlobalItemOptions<T> = DcuplItemOptions<T> & {
     listKey: string;
 };
-export declare type DcuplGlobalQueryOptions<T> = DcuplItemsOptions<T> & {
+export type DcuplGlobalQueryOptions<T> = DcuplItemsOptions<T> & {
     listKey: string;
     query: FilterOptions[];
 };

package/dist/lib-esm/types/filter.types.d.ts

@@ -1,31 +1,31 @@
 import { ListItem } from '.';
 import { CatalogApiOptions } from './list.types';
 import { FilterComparisonType } from './model.types';
-export declare type ConstraintTypes = 'referenceConstraint' | 'textConstraint' | 'numberConstraint' | 'dateConstraint';
-export declare type ConstraintBase = {
+export type ConstraintTypes = 'referenceConstraint' | 'textConstraint' | 'numberConstraint' | 'dateConstraint';
+export type ConstraintBase = {
     uid: string;
     filterKey: string;
     attributeKey: string;
     type: ConstraintTypes;
 };
-export declare type ReferenceConstraint = ConstraintBase & {
+export type ReferenceConstraint = ConstraintBase & {
     type: 'referenceConstraint';
     value: string;
     calculateFacets: boolean;
 };
-export declare type TextConstraint = ConstraintBase & {
+export type TextConstraint = ConstraintBase & {
     type: 'textConstraint';
     comparisonType: FilterComparisonType;
     value: string;
 };
-export declare type NumberConstraint = ConstraintBase & NumberConstraintOperators & {
+export type NumberConstraint = ConstraintBase & NumberConstraintOperators & {
     type: 'numberConstraint';
 };
-export declare type DateConstraint = ConstraintBase & DateConstraintOperators & {
+export type DateConstraint = ConstraintBase & DateConstraintOperators & {
     type: 'dateConstraint';
 };
-export declare type FilterConstraint = ReferenceConstraint | TextConstraint | NumberConstraint | DateConstraint;
-export declare type NumberConstraintOperators = {
+export type FilterConstraint = ReferenceConstraint | TextConstraint | NumberConstraint | DateConstraint;
+export type NumberConstraintOperators = {
     gt?: number;
     lt?: number;
     gte?: number;
@@ -33,7 +33,7 @@ export declare type NumberConstraintOperators = {
     eq?: number | number[];
     ne?: number | number[];
 };
-export declare type DateConstraintOperators = {
+export type DateConstraintOperators = {
     gt?: Date;
     lt?: Date;
     gte?: Date;
@@ -41,18 +41,18 @@ export declare type DateConstraintOperators = {
     eq?: Date | Date[];
     ne?: Date | Date[];
 };
-export declare type FilterEntryNumberRange = {
+export type FilterEntryNumberRange = {
     min: number;
     max: number;
 };
-export declare type FilterEntryDateRange = {
+export type FilterEntryDateRange = {
     min: Date;
     max: Date;
 };
-export declare type FilterItemType = 'reference' | 'number' | 'text' | 'date';
-export declare type FilterItemPropertyType = 'number' | 'text' | 'date';
-export declare type FilterItemReferenceType = 'reference';
-export declare type FilterItemBase = {
+export type FilterItemType = 'reference' | 'number' | 'text' | 'date';
+export type FilterItemPropertyType = 'number' | 'text' | 'date';
+export type FilterItemReferenceType = 'reference';
+export type FilterItemBase = {
     key: string;
     attributeKey: string;
     enabled: boolean;
@@ -62,36 +62,36 @@ export declare type FilterItemBase = {
     range?: FilterItemNumberRangeValue | FilterItemDateRangeValue;
     entries?: Array<FilterItemEntry>;
 };
-export declare type TextFilterItem = FilterItemBase & {
+export type TextFilterItem = FilterItemBase & {
     type: 'text';
     comparisonType: FilterComparisonType;
     text: string;
 };
-export declare type NumberFilterItem = FilterItemBase & {
+export type NumberFilterItem = FilterItemBase & {
     type: 'number';
     range: FilterItemNumberRangeValue;
 };
-export declare type DateFilterItem = FilterItemBase & {
+export type DateFilterItem = FilterItemBase & {
     type: 'date';
     range: FilterItemDateRangeValue;
 };
-export declare type FilterItemNumberRangeValue = {
+export type FilterItemNumberRangeValue = {
     available: FilterEntryNumberRange;
     initial: FilterEntryNumberRange;
     selected: NumberConstraintOperators[];
 };
-export declare type FilterItemDateRangeValue = {
+export type FilterItemDateRangeValue = {
     available: FilterEntryDateRange;
     initial: FilterEntryDateRange;
     selected: DateConstraintOperators[];
 };
-export declare type ReferenceFilterItem = FilterItemBase & {
+export type ReferenceFilterItem = FilterItemBase & {
     type: 'reference';
     entries: Array<FilterItemEntry>;
 };
-export declare type PropertyFilterItem = TextFilterItem | NumberFilterItem | DateFilterItem;
-export declare type FilterItem = PropertyFilterItem | ReferenceFilterItem;
-export declare type FilterItemEntry = {
+export type PropertyFilterItem = TextFilterItem | NumberFilterItem | DateFilterItem;
+export type FilterItem = PropertyFilterItem | ReferenceFilterItem;
+export type FilterItemEntry = {
     key: string;
     enabled: boolean;
     selected: boolean;
@@ -101,8 +101,8 @@ export declare type FilterItemEntry = {
     resultKeys: string[];
     children?: Array<FilterItemEntry>;
 };
-export declare type FilterMode = 'add' | 'set';
-export declare type BaseFilterOptions = {
+export type FilterMode = 'add' | 'set';
+export type BaseFilterOptions = {
     type: FilterType;
     filterKey: string;
     /**
@@ -111,24 +111,24 @@ export declare type BaseFilterOptions = {
      */
     mode?: FilterMode;
 } & CatalogApiOptions;
-export declare type FilterType = 'text' | 'number' | 'reference' | 'date';
-declare type TextFilterOptionsFull = BaseFilterOptions & {
+export type FilterType = 'text' | 'number' | 'reference' | 'date';
+type TextFilterOptionsFull = BaseFilterOptions & {
     type: 'text';
     text: string;
 };
-declare type NumberFilterOptionsFull = BaseFilterOptions & NumberConstraintOperators & {
+type NumberFilterOptionsFull = BaseFilterOptions & NumberConstraintOperators & {
     type: 'number';
 };
-declare type DateFilterOptionsFull = BaseFilterOptions & DateConstraintOperators & {
+type DateFilterOptionsFull = BaseFilterOptions & DateConstraintOperators & {
     type: 'date';
 };
-declare type ReferenceFilterOptionsFull = BaseFilterOptions & {
+type ReferenceFilterOptionsFull = BaseFilterOptions & {
     type: 'reference';
     itemKeys: string[];
 };
-export declare type FilterOptions = TextFilterOptionsFull | NumberFilterOptionsFull | DateFilterOptionsFull | ReferenceFilterOptionsFull;
-export declare type TextFilterOptions = Omit<TextFilterOptionsFull, 'type'>;
-export declare type NumberFilterOptions = Omit<NumberFilterOptionsFull, 'type'>;
-export declare type DateFilterOptions = Omit<DateFilterOptionsFull, 'type'>;
-export declare type ReferenceFilterOptions = Omit<ReferenceFilterOptionsFull, 'type'>;
+export type FilterOptions = TextFilterOptionsFull | NumberFilterOptionsFull | DateFilterOptionsFull | ReferenceFilterOptionsFull;
+export type TextFilterOptions = Omit<TextFilterOptionsFull, 'type'>;
+export type NumberFilterOptions = Omit<NumberFilterOptionsFull, 'type'>;
+export type DateFilterOptions = Omit<DateFilterOptionsFull, 'type'>;
+export type ReferenceFilterOptions = Omit<ReferenceFilterOptionsFull, 'type'>;
 export {};

package/dist/lib-esm/types/internal.types.d.ts

@@ -1,5 +1,5 @@
 import { ListItem } from './data.types';
-export declare type InverseIndexReferenceMap = Map<string, InverseIndexValuesMap>;
-export declare type InverseIndexValuesMap = Map<string, string[]>;
-export declare type InverseIndexDataMap = Map<string, InverseIndexDataValuesMap>;
-export declare type InverseIndexDataValuesMap = Map<string, ListItem>;
+export type InverseIndexReferenceMap = Map<string, InverseIndexValuesMap>;
+export type InverseIndexValuesMap = Map<string, string[]>;
+export type InverseIndexDataMap = Map<string, InverseIndexDataValuesMap>;
+export type InverseIndexDataValuesMap = Map<string, ListItem>;

package/dist/lib-esm/types/list.types.d.ts

@@ -1,50 +1,52 @@
 import { FilterConstraint } from './filter.types';
 import { ViewDefinition, ModelAttribute } from './model.types';
 import { Projection, SortingProjection } from './projection.types';
-export declare type DcuplItemsOptions<T> = {
+export type DcuplItemsOptions<T> = {
     start?: number;
     count?: number;
     projection?: Projection<T>;
     sort?: SortingProjection<T>;
 };
-export declare type DcuplItemOptions<T> = {
+export type DcuplItemOptions<T> = {
     projection?: Projection<T>;
     itemKey: string;
 };
-export declare type DcuplSectionItemOption<T> = DcuplItemsOptions<T> & {
+export type DcuplSectionItemOption<T> = DcuplItemsOptions<T> & {
     key: string;
 };
-export declare type DcuplSectionOptions<T> = DcuplItemsOptions<T> & {
+export type DcuplSectionOptions<T> = DcuplItemsOptions<T> & {
     primaryAttribute: string;
     aggregates?: string[];
     items?: DcuplSectionItemOption<T>[];
 };
-export declare type DcuplFilterOptions = CatalogApiOptions & {
+export type DcuplFilterOptions = CatalogApiOptions & {
     calculateFacets?: boolean;
     excludeZeros?: boolean;
+    excludeUndefineds?: boolean;
     count?: number;
 };
-export declare type DcuplFiltersOptions = DcuplFilterOptions & {
+export type DcuplFiltersOptions = DcuplFilterOptions & {
     filterKeys?: string[];
 };
-export declare type DcuplListOptions<ModelNames extends string = string> = {
+export type DcuplListOptions<ModelNames extends string = string> = {
     listKey: ModelNames;
     name?: string;
     listItemKeys?: string[];
     empty?: boolean;
 };
-export declare type DcuplRangeOptions = {
+export type DcuplRangeOptions = {
     propertyKey: string;
     filterKey?: string;
 };
-export declare type DcuplFacetOptions = {
+export type DcuplFacetOptions = {
     attributeKey: string;
     filterKey?: string;
     count?: number;
     excludeZeros?: boolean;
+    excludeUndefineds?: boolean;
     calculateFacets?: boolean;
 };
-export declare type ListMetadata = {
+export type ListMetadata = {
     key: string;
     currentSize: number;
     initialSize: number;
@@ -53,49 +55,49 @@ export declare type ListMetadata = {
     itemOptions: DcuplItemsOptions<any>;
     views: ViewDefinition[];
 };
-export declare type ViewMetadata = {
+export type ViewMetadata = {
     key: string;
     currentSize: number;
     initialSize: number;
 };
-export declare type AggregationOptions = {
+export type AggregationOptions = {
     attributeKeys: string[];
 };
-export declare type AggregateType = 'number' | 'reference' | 'string';
-export declare type AggregateBase = {
+export type AggregateType = 'number' | 'reference' | 'string';
+export type AggregateBase = {
     attribute: string;
     type: AggregateType;
 };
-export declare type NumberAggregation = AggregateBase & {
+export type NumberAggregation = AggregateBase & {
     attribute: string;
     type: 'number';
     value: NumberAggregationValue;
 };
-export declare type ReferenceAggregation = AggregateBase & {
+export type ReferenceAggregation = AggregateBase & {
     attribute: string;
     type: 'reference';
     value: ReferenceAggregationValue[];
 };
-export declare type StringAggregation = AggregateBase & {
+export type StringAggregation = AggregateBase & {
     attribute: string;
     type: 'string';
     value: StringAggregationValue[];
 };
-export declare type Aggregation = NumberAggregation | StringAggregation | ReferenceAggregation;
-export declare type NumberAggregationValue = {
+export type Aggregation = NumberAggregation | StringAggregation | ReferenceAggregation;
+export type NumberAggregationValue = {
     average: number;
     count: number;
     sum: number;
 };
-export declare type ReferenceAggregationValue = {
+export type ReferenceAggregationValue = {
     value: string;
     count: number;
     itemKeys: string[];
 };
-export declare type StringAggregationValue = {
+export type StringAggregationValue = {
     value: string;
     count: number;
 };
-export declare type CatalogApiOptions = {
+export type CatalogApiOptions = {
     skipProcessing?: boolean;
 };

package/dist/lib-esm/types/model.types.d.ts

@@ -1,5 +1,5 @@
 import { RawItem } from '.';
-export declare type PropertyType = 'string' | 'int' | 'float' | 'json' | 'date' | 'any' | 'Array<string>' | 'Array<int>' | 'Array<float>' | 'Array<date>';
+export type PropertyType = 'string' | 'int' | 'float' | 'json' | 'date' | 'any' | 'Array<string>' | 'Array<int>' | 'Array<float>' | 'Array<date>';
 export declare const NumberPropertyTypes: PropertyType[];
 export declare const DatePropertyTypes: PropertyType[];
 /**
@@ -14,20 +14,20 @@ export declare const DatePropertyTypes: PropertyType[];
  * @ignoreThis 2
  * @important
  */
-export declare type ReferenceType = 'singleValued' | 'multiValued';
-export declare type AttributeType = PropertyType | ReferenceType;
-export declare type ModelMetadata = {
+export type ReferenceType = 'singleValued' | 'multiValued';
+export type AttributeType = PropertyType | ReferenceType;
+export type ModelMetadata = {
     name: string;
     description?: string;
     [key: string]: any;
 };
-export declare type FilterComparisonType = 'equal' | 'equalIgnoreCase' | 'contains' | 'containsIgnoreCase' | 'containsIgnoreCaseAndWhitespace';
+export type FilterComparisonType = 'equal' | 'equalIgnoreCase' | 'contains' | 'containsIgnoreCase' | 'containsIgnoreCaseAndWhitespace';
 /**
  * A property is a quality or characteristic belonging an object.
  * @defaultSnippets {"label":"Property", "properties":["key","type"]}
  *
  */
-declare type PropertyBase = {
+type PropertyBase = {
     /**
      * A key is an unique identifier overall properties in this model.
      *
@@ -44,74 +44,76 @@ declare type PropertyBase = {
         separator?: string;
     };
     meta?: ModelMetadata;
+    index?: boolean;
 };
-export declare type PropertyInt = PropertyBase & {
+export type PropertyInt = PropertyBase & {
     type: 'int' | 'Array<int>';
     aggregate?: boolean;
     filter?: boolean | FilterNumberArray[];
 };
-export declare type PropertyFloat = PropertyBase & {
+export type PropertyFloat = PropertyBase & {
     type: 'float' | 'Array<float>';
     aggregate?: boolean;
     fractionDigits?: number;
     filter?: boolean | FilterNumberArray[];
 };
-export declare type FilterNumberArray = {
+export type FilterNumberArray = {
     key: string;
 };
-export declare type PropertyJson = PropertyBase & {
+export type PropertyJson = PropertyBase & {
     type: 'json' | 'Array<json>';
     filter?: boolean;
 };
-export declare type PropertyAny = PropertyBase & {
+export type PropertyAny = PropertyBase & {
     type: 'any' | 'Array<any>';
 };
-export declare type PropertyDateInputFormat = 'date' | 'ts_seconds' | 'ts_milliseconds' | 'string';
-export declare type PropertyDate = PropertyBase & {
+export type PropertyDateInputFormat = 'date' | 'ts_seconds' | 'ts_milliseconds' | 'string';
+export type PropertyDate = PropertyBase & {
     type: 'date' | 'Array<date>';
     inputFormat?: PropertyDateInputFormat;
     filter?: boolean;
 };
-export declare type PropertyString = PropertyBase & {
+export type PropertyString = PropertyBase & {
     type: 'string' | 'Array<string>';
     filter?: boolean | FilterStringSingle | FilterStringArray[];
 };
-export declare type PropertyExpression = PropertyBase & {
+export type PropertyExpression = PropertyBase & {
     type: 'string';
     expression: string;
     filter?: boolean | FilterStringSingle | FilterStringArray[];
 };
-export declare type PropertyNumber = PropertyFloat | PropertyInt;
-export declare type Property = PropertyExpression | PropertyString | PropertyInt | PropertyFloat | PropertyDate | PropertyJson | PropertyAny;
-export declare type PropertyDerived = Property & {
+export type PropertyNumber = PropertyFloat | PropertyInt;
+export type Property = PropertyExpression | PropertyString | PropertyInt | PropertyFloat | PropertyDate | PropertyJson | PropertyAny;
+export type PropertyDerived = Property & {
     derive: {
         localReference: string;
         remoteProperty: string;
     };
 };
-export declare type PropertyAggregate = (PropertyNumber | PropertyString) & {
+export type PropertyAggregate = (PropertyNumber | PropertyString) & {
     aggregate: true;
 };
-export declare type FilterStringArray = {
+export type FilterStringArray = {
     key: string;
     comparisonType: FilterComparisonType;
 };
-export declare type FilterStringSingle = {
+export type FilterStringSingle = {
     comparisonType?: FilterComparisonType;
 };
 /**
  * Facet calculation is disabled by default
  */
-export declare type ReferenceFilterDefinition = {
+export type ReferenceFilterDefinition = {
     calculateFacets?: boolean;
     excludeZeros?: boolean;
+    excludeUndefineds?: boolean;
 };
-export declare type ReferenceValidity = 'loose' | 'strict';
+export type ReferenceValidity = 'loose' | 'strict';
 /**
  * A Reference prepresent a list of elements along a explicite dimension.
  * @defaultSnippets {"label":"Reference", "properties":["key","model", "type"]}
  */
-export declare type ReferenceBase = {
+export type ReferenceBase = {
     /**
      * A key is an unique identifier for all reference in this model.
      *
@@ -135,11 +137,12 @@ export declare type ReferenceBase = {
     validity?: ReferenceValidity;
     aggregate?: boolean;
     meta?: ModelMetadata;
+    index?: boolean;
 };
-export declare type AggregatedReference = ReferenceBase & {
+export type AggregatedReference = ReferenceBase & {
     aggregate: true;
 };
-export declare type ResolvedReference = ReferenceBase & {
+export type ResolvedReference = ReferenceBase & {
     type: 'multiValued';
     /**
      * Resolve a Relationship to an foreign model
@@ -163,7 +166,7 @@ export declare type ResolvedReference = ReferenceBase & {
         model: string;
     };
 };
-export declare type DerivedReference = ReferenceBase & {
+export type DerivedReference = ReferenceBase & {
     type: ReferenceType;
     /**
      * Derive a specific value from an other object/entity
@@ -186,7 +189,7 @@ export declare type DerivedReference = ReferenceBase & {
         remoteReference: string;
     };
 };
-export declare type GroupedRefeference = ReferenceBase & {
+export type GroupedRefeference = ReferenceBase & {
     type: ReferenceType;
     /**
      * Group by a specific reference
@@ -203,23 +206,23 @@ export declare type GroupedRefeference = ReferenceBase & {
         includeSelfInGroup?: boolean;
     };
 };
-export declare type Reference = ResolvedReference | DerivedReference | GroupedRefeference | ReferenceBase;
-export declare type ValueMappingValue = string | '$dcupl_falsy';
-export declare type ValueMappingValues = {
+export type Reference = ResolvedReference | DerivedReference | GroupedRefeference | ReferenceBase;
+export type ValueMappingValue = string | '$dcupl_falsy';
+export type ValueMappingValues = {
     from: ValueMappingValue[];
     to: string;
 };
-export declare type ValueMappingConfig = {
+export type ValueMappingConfig = {
     attributes: string[];
     values: ValueMappingValues[];
 };
-export declare type ModelAttribute = Property | Reference;
+export type ModelAttribute = Property | Reference;
 /**
  * A model describes a real world object and hols attributes.
  *
  *  @defaultSnippets {"label":"Model Description", "properties":["key:string", "properties:array", "references:array"]}
  */
-export declare type ModelDefinition<ModelNames extends string = string> = {
+export type ModelDefinition<ModelNames extends string = string> = {
     /**
      * The key is an unique identifier overall models in the application.
      *
@@ -235,13 +238,13 @@ export declare type ModelDefinition<ModelNames extends string = string> = {
     valueMappings?: ValueMappingConfig[];
     meta?: ModelMetadata;
 };
-export declare type DcuplViewType = 'section';
+export type DcuplViewType = 'section';
 /**
  * A model describes a real world object and hols attributes.
  *
  *  @defaultSnippets { "label": "Dcupl View", "properties": ["key", "model", "type", "primaryAttribute", "aggregates:array"] }
  */
-export declare type ViewDefinition = {
+export type ViewDefinition = {
     /**
      * The key is an unique identifier overall models in the application.
      *
@@ -267,5 +270,5 @@ export declare type ViewDefinition = {
  * Container for ModelDescriptions & Views
  *
  */
-export declare type Model = ViewDefinition | ModelDefinition | Array<ModelDefinition | ViewDefinition>;
+export type Model = ViewDefinition | ModelDefinition | Array<ModelDefinition | ViewDefinition>;
 export {};

package/dist/lib-esm/types/projection.types.d.ts

@@ -1,14 +1,15 @@
-declare type ArrayOfProperties<T, P extends keyof T> = Exclude<P, 'filterables'>[];
-declare type WildCard = {
+type ArrayOfProperties<T, P extends keyof T> = Exclude<P, 'filterables'>[];
+type WildCard = {
     $?: boolean;
+    $$?: boolean;
 };
-declare type CleanResultItem<T> = Omit<T, 'filterables'>;
-export declare type ProjectionAdvanced<T> = {
+type CleanResultItem<T> = Omit<T, 'filterables'>;
+export type ProjectionAdvanced<T> = {
     [P in keyof CleanResultItem<T>]?: boolean | WildCard | ProjectionAdvanced<T[P]>;
 };
-export declare type Projection<T> = WildCard | ProjectionAdvanced<T>;
-export declare type SortDirection = 'ASC' | 'DESC';
-export declare type SortingProjection<T> = {
+export type Projection<T> = WildCard | ProjectionAdvanced<T>;
+export type SortDirection = 'ASC' | 'DESC';
+export type SortingProjection<T> = {
     attributes: ArrayOfProperties<T, keyof T>;
     order: SortDirection[];
 };

package/dist/lib-esm/types/section.types.d.ts

@@ -1,6 +1,6 @@
 import { ListItem } from './data.types';
 import { Aggregation } from './list.types';
-export declare type SectionItem = ListItem & {
+export type SectionItem = ListItem & {
     _meta: {
         size: number;
     };

package/dist/lib-esm/types/selection.types.d.ts

@@ -1,11 +1,11 @@
-export declare type DcuplSelectionProperty = {
+export type DcuplSelectionProperty = {
     [key: string]: any;
 };
-export declare type DcuplSelectionItem = {
+export type DcuplSelectionItem = {
     key: string;
     properties: DcuplSelectionProperty;
 };
-export declare type DcuplSelection = {
+export type DcuplSelection = {
     uid?: string;
     selectionKey: string;
     listKey?: string;

package/dist/lib-esm/types/suggestion.types.d.ts

@@ -1,14 +1,14 @@
 import { CatalogApiOptions } from './list.types';
 import { FilterComparisonType } from './model.types';
-export declare type SuggestionValueEntry = {
+export type SuggestionValueEntry = {
     key: string;
     value: string;
 };
-export declare type Suggestion<T extends string | SuggestionValueEntry = string> = {
+export type Suggestion<T extends string | SuggestionValueEntry = string> = {
     value: T;
     filterKey: string;
 };
-export declare type SuggestionOptions = CatalogApiOptions & {
+export type SuggestionOptions = CatalogApiOptions & {
     filterKey: string;
     searchTerm: string;
     max?: number;