@pristine-ts/data-mapping 0.0.281 → 0.0.283

package/dist/types/builders/data-mapping.builder.d.ts

@@ -1,110 +0,0 @@
-import { DataMappingNode } from "../nodes/data-mapping.node";
-import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
-import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
-import { DataMappingLeaf } from "../nodes/data-mapping.leaf";
-import { BaseDataMappingNode } from "../nodes/base-data-mapping.node";
-export declare class DataMappingBuilder extends BaseDataMappingNode {
-    normalizers: {
-        key: DataNormalizerUniqueKey;
-        options: any;
-    }[];
-    beforeMappingInterceptors: {
-        key: DataMappingInterceptorUniqueKeyType;
-        options: any;
-    }[];
-    afterMappingInterceptors: {
-        key: DataMappingInterceptorUniqueKeyType;
-        options: any;
-    }[];
-    /**
-     * This method adds a normalizer to the root that will be applied on each node (unless they explicitly exclude to do
-     * so).
-     *
-     * @param normalizerUniqueKey
-     * @param options
-     */
-    addNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey, options?: any): DataMappingBuilder;
-    /**
-     * This method returns whether there's a normalizer for the specified key or not.
-     *
-     * @param normalizerUniqueKey
-     */
-    hasNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey): boolean;
-    /**
-     * This method adds an interceptor that will be executed **before** the object is mapped.
-     *
-     * @param key
-     * @param options
-     */
-    addBeforeMappingInterceptor(key: DataMappingInterceptorUniqueKeyType, options?: any): DataMappingBuilder;
-    /**
-     * This method returns whether a **before** interceptor already exists.
-     * @param key
-     */
-    hasBeforeMappingInterceptor(key: DataMappingInterceptorUniqueKeyType): boolean;
-    /**
-     * This method adds an interceptor that will be executed **after** the object is mapped.
-     *
-     * @param key
-     * @param options
-     */
-    addAfterMappingInterceptor(key: DataMappingInterceptorUniqueKeyType, options?: any): DataMappingBuilder;
-    /**
-     * This method returns whether a **after** interceptor already exists.
-     * @param key
-     */
-    hasAfterMappingInterceptor(key: DataMappingInterceptorUniqueKeyType): boolean;
-    /**
-     * This property creates a new DataMappingLeaf and returns it. It doesn't add it yet. To do so, the `end()` method
-     * must be called.
-     */
-    add(): DataMappingLeaf;
-    /**
-     * This method adds a nesting level. This should be used when the property contains an object and you want to map
-     * this object into another object.
-     */
-    addNestingLevel(): DataMappingNode;
-    /**
-     * This method adds an array of Scalar allowing you to apply the normalizer on each scalar in the array. The
-     * `sourceProperty` and `destinationProperty` correspond to the name of the property that is an array. But, the
-     * values in the array will be normalized using the normalizer.
-     *
-     */
-    addArrayOfScalar(): DataMappingLeaf;
-    /**
-     * This method adds an array of objects allowing to define a node for each property in the object. Each object in
-     * the array will be treated as being the same.
-     */
-    addArrayOfObjects(): DataMappingNode;
-    /**
-     * This method is called at the end just to make it nice since all the nodes will have one, it's nice
-     * that the builder has one too.
-     */
-    end(): DataMappingBuilder;
-    /**
-     * This method imports a schema.
-     *
-     * @param schema
-     */
-    import(schema: any): void;
-    /**
-     * This method exports this node.
-     */
-    export(): {
-        nodes: {
-            [x: string]: DataMappingLeaf | DataMappingNode;
-        };
-        normalizers: {
-            key: string;
-            options: any;
-        }[];
-        beforeMappingInterceptors: {
-            key: string;
-            options: any;
-        }[];
-        afterMappingInterceptors: {
-            key: string;
-            options: any;
-        }[];
-    };
-}

package/dist/types/enums/data-mapping-node-type.enum.d.ts

@@ -1,6 +0,0 @@
-export declare enum DataMappingNodeTypeEnum {
-    ScalarArray = "DATA_MAPPING_NODE_SCALAR_ARRAY",
-    ObjectArray = "DATA_MAPPING_NODE_OBJECT_ARRAY",
-    Node = "DATA_MAPPING_NODE",
-    Leaf = "DATA_MAPPING_LEAF"
-}

package/dist/types/enums/enums.d.ts

@@ -1 +0,0 @@
-export * from "./data-mapping-node-type.enum";

package/dist/types/errors/array-data-mapping-node-invalid-source-property-type.error.d.ts

@@ -1,7 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-/**
- * This Error is thrown when a node is of type array but the `source[sourceProperty]` doesn't actually contain an array.
- */
-export declare class ArrayDataMappingNodeInvalidSourcePropertyTypeError extends LoggableError {
-    constructor(message: string, sourceProperty: string);
-}

package/dist/types/errors/data-after-mapping-interceptor-already-added.error.d.ts

@@ -1,8 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
-/**
- * This Error is thrown when the before row interceptor is added more than once to the builder.
- */
-export declare class DataAfterMappingInterceptorAlreadyAddedError extends LoggableError {
-    constructor(message: string, uniqueKey: DataMappingInterceptorUniqueKeyType, options?: any);
-}

package/dist/types/errors/data-before-mapping-interceptor-already-added.error.d.ts

@@ -1,8 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
-/**
- * This Error is thrown when the after row interceptor is added more than once to the builder.
- */
-export declare class DataBeforeMappingInterceptorAlreadyAddedError extends LoggableError {
-    constructor(message: string, uniqueKey: DataMappingInterceptorUniqueKeyType, options?: any);
-}

package/dist/types/errors/data-mapping-interceptor-not-found.error.d.ts

@@ -1,8 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
-/**
- * This Error is thrown if the Data Transformer Class is not found in the list of available interceptors. It might be missing a tag.
- */
-export declare class DataMappingInterceptorNotFoundError extends LoggableError {
-    constructor(message: string, uniqueKey: DataMappingInterceptorUniqueKeyType, options?: any);
-}

package/dist/types/errors/data-mapping-source-property-not-found.error.d.ts

@@ -1,7 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-/**
- * This Error is thrown when a property isn't optional and should be found in the source object.
- */
-export declare class DataMappingSourcePropertyNotFoundError extends LoggableError {
-    constructor(message: string, sourceProperty: string);
-}

package/dist/types/errors/data-normalizer-already-added.error.d.ts

@@ -1,7 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-/**
- * This Error is thrown when a normalizer is added more than once.
- */
-export declare class DataNormalizerAlreadyAdded extends LoggableError {
-    constructor(message: string, normalizerUniqueKey: string, options?: any);
-}

package/dist/types/errors/errors.d.ts

@@ -1,8 +0,0 @@
-export * from "./array-data-mapping-node-invalid-source-property-type.error";
-export * from "./data-after-mapping-interceptor-already-added.error";
-export * from "./data-before-mapping-interceptor-already-added.error";
-export * from "./data-normalizer-already-added.error";
-export * from "./data-mapping-interceptor-not-found.error";
-export * from "./data-mapping-source-property-not-found.error";
-export * from "./normalizer-invalid-source-type.error";
-export * from "./undefined-source-property.error";

package/dist/types/errors/normalizer-invalid-source-type.error.d.ts

@@ -1,7 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-/**
- * This Error is thrown when an invalid source type is passed to the source type while the normalizer expects another type.
- */
-export declare class NormalizerInvalidSourceTypeError extends LoggableError {
-    constructor(message: string, normalizerUniqueKey: string, options: any, source: any, sourceType: any);
-}

package/dist/types/errors/undefined-source-property.error.d.ts

@@ -1,9 +0,0 @@
-import { LoggableError } from "@pristine-ts/common";
-import { DataMappingLeaf } from "../nodes/data-mapping.leaf";
-import { DataMappingNode } from "../nodes/data-mapping.node";
-/**
- * This Error is thrown when you are trying to add a Node which has an undefined sourceProperty value.
- */
-export declare class UndefinedSourcePropertyError extends LoggableError {
-    constructor(node: DataMappingLeaf | DataMappingNode);
-}

package/dist/types/interfaces/data-mapping-interceptor.interface.d.ts

@@ -1,19 +0,0 @@
-import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
-export interface DataMappingInterceptorInterface {
-    /**
-     * Every data mapping interceptor must define a unique key. Then, during the mapping, the schema can specify which
-     * interceptors must be called.
-     */
-    getUniqueKey(): DataMappingInterceptorUniqueKeyType;
-    /**
-     * This method is called before the row is being mapped and normalized. It allows you to combine fields for example if that's what you want.
-     * @param row
-     */
-    beforeMapping(row: any): Promise<any>;
-    /**
-     * This method is called after the row is being mapped and normalized. It can allow you to apply operations on each
-     * field or combine fields for example.
-     * @param row
-     */
-    afterMapping(row: any): Promise<any>;
-}

package/dist/types/interfaces/data-normalizer.interface.d.ts

@@ -1,15 +0,0 @@
-import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
-export interface DataNormalizerInterface<T, R> {
-    /**
-     * Every data normalizer must define a unique key. Then, during the transformation, the schema can specify which
-     * normalizer it must use. Using the unique key, we can quickly (in O(1)) retrieve the normalizer.
-     */
-    getUniqueKey(): DataNormalizerUniqueKey;
-    /**
-     * This method takes the source property value, can receive options to control the behaviour (example, you might
-     * want to specify a number of significant digits or a data format) and returns the normalized value.
-     * @param source
-     * @param options
-     */
-    normalize(source: any, options?: R): T;
-}

package/dist/types/interfaces/interfaces.d.ts

@@ -1,2 +0,0 @@
-export * from "./data-normalizer.interface";
-export * from "./data-mapping-interceptor.interface";

package/dist/types/mappers/data.mapper.d.ts

@@ -1,38 +0,0 @@
-import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
-import { DataMappingInterceptorInterface } from "../interfaces/data-mapping-interceptor.interface";
-import { DataMappingBuilder } from "../builders/data-mapping.builder";
-import { ClassConstructor } from "class-transformer";
-import { AutoDataMappingBuilder } from "../builders/auto-data-mapping.builder";
-import { AutoDataMappingBuilderOptions } from "../options/auto-data-mapping-builder.options";
-export declare class DataMapper {
-    private readonly autoDataMappingBuilder;
-    private readonly dataNormalizers;
-    private readonly dataTransformerInterceptors;
-    private readonly dataNormalizersMap;
-    private readonly dataTransformerInterceptorsMap;
-    constructor(autoDataMappingBuilder: AutoDataMappingBuilder, dataNormalizers: DataNormalizerInterface<any, any>[], dataTransformerInterceptors: DataMappingInterceptorInterface[]);
-    /**
-     * This method takes an array of source and maps each item.
-     *
-     * @param builder
-     * @param source
-     * @param destinationType
-     */
-    mapAll(builder: DataMappingBuilder, source: any[], destinationType?: ClassConstructor<any>): Promise<any[]>;
-    /**
-     * This method automatically maps a source object into the DestinationType.
-     * @param source
-     * @param destinationType
-     * @param options
-     */
-    autoMap(source: any, destinationType: ClassConstructor<any>, options?: AutoDataMappingBuilderOptions): Promise<any>;
-    /**
-     * This method takes a builder, a source and maps it according to the builder. You can pass a `destinationType (optional)`
-     * that is an object that will be constructed.
-     *
-     * @param builder
-     * @param source
-     * @param destinationType
-     */
-    map(builder: DataMappingBuilder, source: any, destinationType?: ClassConstructor<any>): Promise<any>;
-}

package/dist/types/mappers/mappers.d.ts

@@ -1 +0,0 @@
-export * from "./data.mapper";

package/dist/types/nodes/base-data-mapping.node.d.ts

@@ -1,15 +0,0 @@
-import { DataMappingNode } from "./data-mapping.node";
-import { DataMappingLeaf } from "./data-mapping.leaf";
-export declare abstract class BaseDataMappingNode {
-    nodes: {
-        [sourceProperty in string]: DataMappingNode | DataMappingLeaf;
-    };
-    /**
-     * This method is called by the node itself to tell its parent that it has been build and is ready to be added.
-     * We use this mechanism to force the `end()` method on the leaf to be called so we can do some validations before
-     * adding it to the tree.
-     *
-     * @param node
-     */
-    addNode(node: DataMappingLeaf | DataMappingNode): void;
-}

package/dist/types/nodes/data-mapping.leaf.d.ts

@@ -1,92 +0,0 @@
-import { DataMappingNodeTypeEnum } from "../enums/data-mapping-node-type.enum";
-import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
-import { DataMappingBuilder } from "../builders/data-mapping.builder";
-import { DataMappingNode } from "./data-mapping.node";
-import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
-export declare class DataMappingLeaf {
-    private readonly root;
-    readonly parent: DataMappingNode | DataMappingBuilder;
-    readonly type: DataMappingNodeTypeEnum;
-    /**
-     * This property represents the property referenced in the `source` object.
-     */
-    sourceProperty: string;
-    /**
-     * This property represents the property referenced in the `destination` object.
-     */
-    destinationProperty: string;
-    /**
-     * This property contains an array of Normalizers to apply sequentially when mapping this property.
-     */
-    normalizers: {
-        key: DataNormalizerUniqueKey;
-        options: any;
-    }[];
-    /**
-     * This property contains an array of Normalizers that must be excluded from normalizers defined by parents.
-     */
-    excludedNormalizers: Set<DataNormalizerUniqueKey>;
-    /**
-     * This method specified whether it's possible that this element not be present in the `source` object.
-     */
-    isOptional: boolean;
-    constructor(root: DataMappingBuilder, parent: DataMappingNode | DataMappingBuilder, type?: DataMappingNodeTypeEnum);
-    /**
-     * This is a setter for `sourceProperty`.
-     * @param sourceProperty
-     */
-    setSourceProperty(sourceProperty: string): DataMappingLeaf;
-    /**
-     * This is a setter for `destinationProperty`.
-     * @param destinationProperty
-     */
-    setDestinationProperty(destinationProperty: string): DataMappingLeaf;
-    /**
-     * This is a setter for `isOptional`.
-     * @param isOptional
-     */
-    setIsOptional(isOptional: boolean): DataMappingLeaf;
-    /**
-     * This methods adds a normalizer but checks that this normalizer hasn't been added already (either at the root) or
-     * directly on this leaf.
-     *
-     * @param normalizerUniqueKey
-     * @param options
-     */
-    addNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey, options?: any): DataMappingLeaf;
-    /**
-     * This method simply returns whether the normalizer was already added to this node.
-     * @param normalizerUniqueKey
-     */
-    hasNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey): boolean;
-    /**
-     * This method adds a normalizer that must be excluded from the normalizers applied at a higher level.à
-     * @param normalizerUniqueKey
-     */
-    excludeNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey): DataMappingLeaf;
-    /**
-     * This method adds this node to its parent and returns the parent.
-     */
-    end(): DataMappingNode | DataMappingBuilder;
-    /**
-     * This method maps the `sourceProperty` from the `source` object and maps it to the `destinationProperty` of the
-     * `destination` object while applying the normalizers.
-     *
-     * @param source
-     * @param destination
-     * @param normalizersMap
-     */
-    map(source: any, destination: any, normalizersMap: {
-        [key in DataNormalizerUniqueKey]: DataNormalizerInterface<any, any>;
-    }): Promise<void>;
-    /**
-     * This method imports a schema.
-     *
-     * @param schema
-     */
-    import(schema: any): void;
-    /**
-     * This method exports this node.
-     */
-    export(): any;
-}

package/dist/types/nodes/data-mapping.node.d.ts

@@ -1,104 +0,0 @@
-import { DataMappingNodeTypeEnum } from "../enums/data-mapping-node-type.enum";
-import { DataMappingLeaf } from "./data-mapping.leaf";
-import { DataMappingBuilder } from "../builders/data-mapping.builder";
-import { BaseDataMappingNode } from "./base-data-mapping.node";
-import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
-import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
-import { ClassConstructor } from "class-transformer";
-export declare class DataMappingNode extends BaseDataMappingNode {
-    readonly root: DataMappingBuilder;
-    readonly parent: DataMappingNode | DataMappingBuilder;
-    readonly type: DataMappingNodeTypeEnum;
-    /**
-     * This property represents the property referenced in the `source` object.
-     */
-    sourceProperty: string;
-    /**
-     * This property represents the property referenced in the `destination` object.
-     */
-    destinationProperty: string;
-    /**
-     * This method specified whether it's possible that this element not be present in the `source` object.
-     */
-    isOptional: boolean;
-    /**
-     * IMPORTANT: This property is not serializable. It will be lost during the export.
-     */
-    destinationType?: ClassConstructor<any>;
-    constructor(root: DataMappingBuilder, parent: DataMappingNode | DataMappingBuilder, type?: DataMappingNodeTypeEnum);
-    /**
-     * This is a setter for `sourceProperty`.
-     * @param sourceProperty
-     */
-    setSourceProperty(sourceProperty: string): DataMappingNode;
-    /**
-     * This is a setter for `destinationProperty`.
-     * @param destinationProperty
-     */
-    setDestinationProperty(destinationProperty: string): DataMappingNode;
-    /**
-     * This is a setter for `destinationType`.
-     * @param destinationType
-     */
-    setDestinationType(destinationType: ClassConstructor<any>): DataMappingNode;
-    /**
-     * This is a setter for `isOptional`.
-     * @param isOptional
-     */
-    setIsOptional(isOptional: boolean): DataMappingNode;
-    /**
-     * This property creates a new DataMappingLeaf and returns it. It doesn't add it yet. To do so, the `end()` method
-     * must be called.
-     */
-    add(): DataMappingLeaf;
-    /**
-     * This method adds a nesting level. This should be used when the property contains an object and you want to map
-     * this object into another object.
-     */
-    addNestingLevel(): DataMappingNode;
-    /**
-     * This method adds an array of Scalar allowing you to apply the normalizer on each scalar in the array. The
-     * `sourceProperty` and `destinationProperty` correspond to the name of the property that is an array. But, the
-     * values in the array will be normalized using the normalizer.
-     *
-     */
-    addArrayOfScalar(): DataMappingLeaf;
-    /**
-     * This method adds an array of objects allowing to define a node for each property in the object. Each object in
-     * the array will be treated as being the same.
-     */
-    addArrayOfObjects(): DataMappingNode;
-    /**
-     * This method adds this node to its parent and returns the parent.
-     */
-    end(): DataMappingNode | DataMappingBuilder;
-    /**
-     * This method maps the `sourceProperty` from the `source` object and maps it to the `destinationProperty` of the
-     * `destination` object while applying the normalizers.
-     *
-     * @param source
-     * @param destination
-     * @param normalizersMap
-     */
-    map(source: any, destination: any, normalizersMap: {
-        [key in DataNormalizerUniqueKey]: DataNormalizerInterface<any, any>;
-    }): Promise<void>;
-    /**
-     * This method imports a schema.
-     *
-     * @param schema
-     */
-    import(schema: any): void;
-    /**
-     * This method exports this node.
-     */
-    export(): {
-        _type: DataMappingNodeTypeEnum;
-        sourceProperty: string;
-        destinationProperty: string;
-        isOptional: boolean;
-        nodes: {
-            [x: string]: DataMappingLeaf | DataMappingNode;
-        };
-    };
-}

package/dist/types/nodes/nodes.d.ts

@@ -1,3 +0,0 @@
-export * from "./base-data-mapping.node";
-export * from "./data-mapping.leaf";
-export * from "./data-mapping.node";

package/dist/types/normalizer-options/base-normalizer.options.d.ts

@@ -1,4 +0,0 @@
-export declare abstract class BaseNormalizerOptions {
-    shouldThrowIfTypeIsNotString: boolean;
-    constructor(options?: Partial<BaseNormalizerOptions>);
-}

package/dist/types/normalizer-options/date-normalizer.options.d.ts

@@ -1,12 +0,0 @@
-export declare class DateNormalizerOptions {
-    /**
-     * This property specifies whether an invalid date should return undefined or a date object.
-     */
-    returnUndefinedOnInvalidDate: boolean;
-    /**
-     * This property specifies if a number should be treated as being in seconds or not. Since JS Date expects a
-     * timestamp in milliseconds, if the number is in seconds, it will be multiplied by 1000.
-     */
-    treatNumbers: "milliseconds" | "seconds";
-    constructor(options?: Partial<DateNormalizerOptions>);
-}

package/dist/types/normalizer-options/lowercase-normalizer.options.d.ts

@@ -1,4 +0,0 @@
-import { BaseNormalizerOptions } from "./base-normalizer.options";
-export declare class LowercaseNormalizerOptions extends BaseNormalizerOptions {
-    constructor(options?: Partial<LowercaseNormalizerOptions>);
-}

package/dist/types/normalizer-options/normalizer-options.d.ts

@@ -1,5 +0,0 @@
-export * from "./base-normalizer.options";
-export * from "./date-normalizer.options";
-export * from "./lowercase-normalizer.options";
-export * from "./number-normalizer.options";
-export * from "./string-normalizer.options";

package/dist/types/normalizer-options/number-normalizer.options.d.ts

@@ -1,8 +0,0 @@
-export declare class NumberNormalizerOptions {
-    /**
-     * This property specifies whether an undefined value should be ignored and simply returned or treated as a potential string
-     * and return an empty string `""`.
-     */
-    ignoreUndefined: boolean;
-    constructor(options?: Partial<NumberNormalizerOptions>);
-}

package/dist/types/normalizer-options/string-normalizer.options.d.ts

@@ -1,12 +0,0 @@
-export declare class StringNormalizerOptions {
-    /**
-     * This property specifies whether an undefined value should be ignored and simply returned or treated as a potential string
-     * and return an empty string `""`.
-     */
-    ignoreUndefined: boolean;
-    /**
-     * This represents the format of the date that the normalizer should use when outputting a date object to a string.
-     */
-    dateFormat?: string;
-    constructor(options?: Partial<StringNormalizerOptions>);
-}

package/dist/types/normalizers/date.normalizer.d.ts

@@ -1,6 +0,0 @@
-import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
-import { DateNormalizerOptions } from "../normalizer-options/date-normalizer.options";
-export declare class DateNormalizer implements DataNormalizerInterface<Date | undefined, DateNormalizerOptions> {
-    getUniqueKey(): string;
-    normalize(source: any, options?: DateNormalizerOptions): Date | undefined;
-}

package/dist/types/normalizers/lowercase.normalizer.d.ts

@@ -1,7 +0,0 @@
-import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
-import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
-import { LowercaseNormalizerOptions } from "../normalizer-options/lowercase-normalizer.options";
-export declare class LowercaseNormalizer implements DataNormalizerInterface<string, LowercaseNormalizerOptions> {
-    getUniqueKey(): DataNormalizerUniqueKey;
-    normalize(source: any, options?: LowercaseNormalizerOptions): string;
-}

package/dist/types/normalizers/normalizers.d.ts

@@ -1,4 +0,0 @@
-export * from "./date.normalizer";
-export * from "./lowercase.normalizer";
-export * from "./number.normalizer";
-export * from "./string.normalizer";

package/dist/types/normalizers/number.normalizer.d.ts

@@ -1,6 +0,0 @@
-import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
-import { NumberNormalizerOptions } from "../normalizer-options/number-normalizer.options";
-export declare class NumberNormalizer implements DataNormalizerInterface<number | undefined, NumberNormalizerOptions> {
-    getUniqueKey(): string;
-    normalize(source: any, options?: NumberNormalizerOptions): number | undefined;
-}

package/dist/types/normalizers/string.normalizer.d.ts

@@ -1,6 +0,0 @@
-import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
-import { StringNormalizerOptions } from "../normalizer-options/string-normalizer.options";
-export declare class StringNormalizer implements DataNormalizerInterface<string | undefined, StringNormalizerOptions> {
-    getUniqueKey(): string;
-    normalize(source: any, options?: StringNormalizerOptions): string | undefined;
-}

package/dist/types/options/auto-data-mapping-builder.options.d.ts

@@ -1,11 +0,0 @@
-export declare class AutoDataMappingBuilderOptions {
-    /**
-     * This property is used to specify the default value for the `ìsOptional` property in the builder.
-     *
-     * It will not override the `isNullable` metadata for the property.
-     *
-     * Default value is `false`.
-     */
-    isOptionalDefaultValue: boolean;
-    constructor(options?: Partial<AutoDataMappingBuilderOptions>);
-}

package/dist/types/types/data-mapping-interceptor-unique-key.type.d.ts

@@ -1 +0,0 @@
-export type DataMappingInterceptorUniqueKeyType = string;

package/dist/types/types/data-normalizer-unique-key.type.d.ts

@@ -1 +0,0 @@
-export type DataNormalizerUniqueKey = string;

package/dist/types/types/types.d.ts

@@ -1,2 +0,0 @@
-export * from "./data-normalizer-unique-key.type";
-export * from "./data-mapping-interceptor-unique-key.type";