entropic-bond 1.50.0 → 1.50.2

package/lib/store/data-source.d.ts

@@ -0,0 +1,137 @@
+import { Persistent, PersistentObject, Collections } from '../persistent/persistent';
+import { ClassPropNames } from '../types/utility-types';
+export type DocumentObject = PersistentObject<Persistent>;
+/**
+ * The query operators
+ * @param == equal
+ * @param != not equal
+ * @param < less than
+ * @param <= less than or equal
+ * @param > greater than
+ * @param >= greater than or equal
+ * @param contains array contains
+ * @param containsAny array contains any
+ * @param in in
+ * @param !in not in
+ */
+export type QueryOperator = '==' | '!=' | '<' | '<=' | '>' | '>=' | 'contains' | 'containsAny';
+/**
+ * A representation of a query operation
+ * @param property the name of the property to be used in the query
+ * @param operator the operator to be used in the query
+ * @param value the value to be used in the query
+ * @param aggregate if true, the query results will be aggregated using an `or` operator
+ */
+export type QueryOperation<T> = {
+    property: ClassPropNames<T>;
+    operator: QueryOperator;
+    value: Partial<T[ClassPropNames<T>]> | {
+        [key: string]: unknown;
+    };
+    aggregate?: boolean;
+};
+/**
+ * The sort order
+ * @param asc ascending order
+ * @param desc descending order
+ */
+export type QueryOrder = 'asc' | 'desc';
+/**
+ * A representation of a full query
+ * @param operations the query operations to be performed
+ * @param limit the maximum number of items to be retrieved
+ * @param sort sort info
+ * @param sort.order the sort order
+ * @param sort.propertyName the name of the property to be used for sorting
+ */
+export type QueryObject<T> = {
+    operations?: QueryOperation<T>[];
+    limit?: number;
+    sort?: {
+        order: QueryOrder;
+        propertyName: ClassPropNames<T> | string;
+    };
+};
+/**
+ * The data source interface.
+ * It defines the methods that must be implemented by a data source
+ * A data source is able to retrieve and save data i.e: from a database, a file, a RestAPI, etc.
+ * You can derive from this class to implement your own data source with the
+ * A data source is used by the store to retrieve and save data.
+ */
+export declare abstract class DataSource {
+    /**
+     * Retrieves a document by id
+     * Implement the required logic to retrieve a document by id from your concrete
+     * the data source
+     * @param id the id of the document to be retrieved
+     * @param collectionName the name of the collection where the document is stored
+     * @returns a promise resolving to the document object. The document object is
+     * a plain object with the properties of the document class.
+     */
+    abstract findById(id: string, collectionName: string): Promise<DocumentObject>;
+    /**
+     * Retrieves all documents matching the query stored in the query object
+     * Implement the required logic to retrieve the documents that match the
+     * requirements in the query object from your concrete the data source
+     * @param queryObject the query object containing the query operations
+     * @param collectionName the name of the collection where the documents are stored
+     * @returns a promise resolving to an array of document objects. The document object is
+     * a plain object with the properties of the document class.
+     * @see QueryObject
+     * @see QueryOperation
+     * @see QueryOperator
+     * @see QueryOrder
+     * @see DocumentObject
+     */
+    abstract find(queryObject: QueryObject<DocumentObject>, collectionName: string): Promise<DocumentObject[]>;
+    /**
+     * Saves a document
+     * Implement the required logic to save the document in your concrete the data source
+     * @param object A collection of documents to be saved
+     * @returns a promise
+     */
+    abstract save(object: Collections): Promise<void>;
+    /**
+     * Deletes a document by id
+     * Implement the required logic to delete a document by id from your concrete
+     * data source
+     * @param id the id of the document to be deleted
+     * @param collectionName the name of the collection where the document is stored
+     * @returns a promise
+     */
+    abstract delete(id: string, collectionName: string): Promise<void>;
+    /**
+     * Retrieves the next bunch of documents matching the query stored in the query object
+     * Implement the required logic to retrieve the next bunch of documents that match the
+     * requirements in the query object from your concrete the data source
+     * @param limit the maximum number of items to be retrieved
+     * @returns a promise resolving to an array representing the next bunch of document objects
+     */
+    abstract next(limit?: number): Promise<DocumentObject[]>;
+    /**
+     * Retrieves the number of documents matching the query stored in the query object
+     * Implement the required logic to retrieve the number of documents that match the
+     * requirements in the query object from your concrete the data source
+     * @param queryObject the query object containing the query operations
+     * @param collectionName the name of the collection where the documents are stored
+     * @returns a promise resolving to the number of documents matching the query
+     * @see QueryObject
+     */
+    abstract count(queryObject: QueryObject<DocumentObject>, collectionName: string): Promise<number>;
+    /**
+     * Utility method to convert a query object to a property path query object
+     *
+     * @param queryObject the query object to be converted
+     * @returns a property path query object
+     * @example
+     * const queryObject = {
+     * 	operations: [{ property: 'name', operator: '==', value: { ancestorName: { father: 'Felipe' }}]
+     * }
+     * const propPathQueryObject = DataSource.toPropertyPathQueryObject( queryObject )
+     * // returned value: [{ property: 'name.ancestorName.father', operator: '==', value: 'Felipe' }]
+     */
+    static toPropertyPathOperations<T extends Persistent>(operations: QueryOperation<T>[]): QueryOperation<T>[];
+    static isArrayOperator(operator: QueryOperator): boolean;
+    private static toPropertyPathValue;
+}

package/lib/store/json-data-source.d.ts

@@ -0,0 +1,68 @@
+import { Collections, Persistent, PersistentObject } from '../persistent/persistent';
+import { DataSource, DocumentObject, QueryObject } from "./data-source";
+export interface JsonRawData {
+    [collection: string]: {
+        [documentId: string]: PersistentObject<Persistent>;
+    };
+}
+export interface ErrorOnOperation {
+    store: string;
+    find: string;
+    findById: string;
+    delete: string;
+}
+/**
+ * A concrete implementation of the DataSource interface uses an in-memory data store
+ * initialized by a JSON object.
+ * It is useful for testing purposes.
+ * The data in the JSON object is not persisted.
+ */
+export declare class JsonDataSource implements DataSource {
+    /**
+     * @param jsonRawData the JSON object to be used as data store
+     */
+    constructor(jsonRawData?: JsonRawData);
+    /**
+     * Set the JSON object to initialize the data store. Use to set the it after
+     * the constructor has been called.
+     * @param jsonRawData the JSON object to be used as data store
+     */
+    setDataStore(rawDataStore: JsonRawData): this;
+    /**
+     * Introduce a delay in the execution of operations to simulate a real data source
+     * @param miliSeconds the number of milliseconds to delay the execution of operations
+     * @returns a chainable reference to this object
+     */
+    simulateDelay(miliSeconds: number): this;
+    findById(id: string, collectionName: string): Promise<DocumentObject>;
+    save(collections: Collections): Promise<void>;
+    find(queryObject: QueryObject<DocumentObject>, collectionName: string): Promise<DocumentObject[]>;
+    delete(id: string, collectionName: string): Promise<void>;
+    next(limit?: number): Promise<DocumentObject[]>;
+    count(queryObject: QueryObject<DocumentObject>, collectionName: string): Promise<number>;
+    /**
+     * @returns the raw data store data as a JSON object
+     */
+    get rawData(): JsonRawData;
+    /**
+     * Wait for all pending promises to be resolved
+     * @returns a promise that resolves when all pending promises are resolved
+     */
+    wait(): Promise<any[]>;
+    private incCursor;
+    simulateError(error: string | ErrorOnOperation | undefined): this;
+    private decCursor;
+    private queryProcessor;
+    private retrieveQueryDocs;
+    private deepValue;
+    private isQueryMatched;
+    private retrieveValuesToCompare;
+    private resolveWithDelay;
+    private _jsonRawData;
+    private _lastMatchingDocs;
+    private _lastLimit;
+    private _cursor;
+    private _simulateDelay;
+    private _pendingPromises;
+    private _simulateError;
+}

package/lib/store/json-data-source.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/store/mocks/test-user.d.ts

@@ -0,0 +1,49 @@
+import { Persistent } from '../../persistent/persistent';
+interface Name {
+    firstName: string;
+    lastName: string;
+    ancestorName: {
+        father?: string;
+        mother?: string;
+    };
+}
+export declare class SubClass extends Persistent {
+    set year(value: number | undefined);
+    get year(): number | undefined;
+    private _year;
+}
+export declare class TestUser extends Persistent {
+    set name(value: Name | undefined);
+    get name(): Name | undefined;
+    set age(value: number | undefined);
+    get age(): number | undefined;
+    set admin(value: boolean | undefined);
+    get admin(): boolean | undefined;
+    set skills(value: string[] | undefined);
+    get skills(): string[] | undefined;
+    set documentRef(value: SubClass | undefined);
+    get documentRef(): SubClass | undefined;
+    set manyRefs(value: SubClass[]);
+    get manyRefs(): SubClass[];
+    set derived(value: DerivedUser | undefined);
+    get derived(): DerivedUser | undefined;
+    set manyDerived(value: DerivedUser[]);
+    get manyDerived(): DerivedUser[];
+    set colleagues(value: TestUser[]);
+    get colleagues(): TestUser[];
+    private _colleagues;
+    private _name;
+    private _age;
+    private _admin;
+    private _skills;
+    private _documentRef;
+    private _manyRefs;
+    private _derived;
+    private _manyDerived;
+}
+export declare class DerivedUser extends TestUser {
+    set salary(value: number | undefined);
+    get salary(): number | undefined;
+    private _salary;
+}
+export {};

package/lib/store/model.d.ts

@@ -0,0 +1,238 @@
+import { Persistent } from '../persistent/persistent';
+import { ClassPropNames, PropPath, PropPathType } from '../types/utility-types';
+import { DataSource, QueryOperator, QueryObject, QueryOrder } from './data-source';
+/**
+ * Provides abstraction to the database access. You should gain access to a Model
+ * object through the Store.getModel method instead of its constructor.
+ */
+export declare class Model<T extends Persistent> {
+    static error: {
+        persistentNeedForSubCollection: string;
+        invalidQueryOrder: string;
+    };
+    constructor(stream: DataSource, persistentClass: Persistent | string, subCollection?: string);
+    /**
+     * Finds an stored object in the database by its id. The field id is provided
+     * by the Persistent parent class and it is automatically managed. Therefore,
+     * you should obtain the id by looking at the id field of the object.
+     *
+     * @param id the id to look for
+     * @param instance you can pass an instace that will be filled with the found data
+     * @returns a promise resolving to an instance with the found data
+     */
+    findById<D extends T>(id: string, instance?: D): Promise<D | undefined>;
+    /**
+     * Stores an object in the database
+     *
+     * @param instance the object instance to store
+     * @returns a promise
+     */
+    save(instance: T): Promise<void>;
+    /**
+     * Removes an element from the database by id
+     * @param id the id of the element to be removed
+     * @returns a promise
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Call find to retrieve a Query object used to define the search conditions
+     * @returns a Query object
+     */
+    find<U extends T>(): Query<U>;
+    /**
+     * Define the search conditions. You pass query operations and how the query
+     * results are returned to the QueryObject
+     * @param queryObject the QueryObject with the search constrains
+     * @param objectType Deprecated! - restricts the search to a specific instances of the class type
+     * @returns a promise resolving to a collection of matched documents
+     */
+    query<U extends T>(queryObject?: QueryObject<U>, /** @deprecated */ objectType?: U | string): Promise<U[]>;
+    /**
+     * Get the amount of documents matching the query
+     * @param queryObject the QueryObject with the search constrains
+     * @returns a promise resolving to the amount of matched documents
+     */
+    count(queryObject: QueryObject<T>): Promise<number>;
+    /**
+     * Get the next bunch of documents matching the last query
+     * @param limit the max amount of documents to retrieve. If not set, uses the
+     * last limit set
+     * @returns a promise resolving to a collection of matched documents
+     */
+    next<U extends T>(limit?: number): Promise<U[]>;
+    private mapToInstance;
+    /**
+     * Normalizes the query object to match the data source requirements.
+     * Call this method before you do any query operation on the concrete data source
+     * @param queryObject the query object containing the query operations
+     * @param operatorConversor a function that converts the query operators to the
+     * operators supported by the concrete data source
+     * @returns the normalized query object
+     */
+    private preprocessQueryObject;
+    readonly collectionName: string;
+    private _stream;
+}
+/**
+ * The Query class is used to define the search conditions. You can chain
+ * where operations to define the search conditions. The where operations
+ * are stored in a QueryObject that is passed to the query method of the
+ * Model class.
+ */
+export declare class Query<T extends Persistent> {
+    constructor(model: Model<T>);
+    /**
+     * Matches all documents that the value of the property satisfies the condition
+     * in the operator parameter. Subsequent `where` calls will be operated to the
+     * previous ones using the AND operator
+     * @param property the property to be compared
+     * @param operator the operator to be used in the comparison. The available
+     * operators are: ==, !=, >, >=, < and <=
+     * @param value the value to be compared
+     * @param aggregate if true, the query will use the logical or operator and
+     * aggregate the results to the previous query
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.where( 'name', '==', 'John' )
+     * query.where( 'age', '>', 18 )
+     * query.where( 'age', '==', 18 ).where( 'name', '==', 'John' )
+     * @see whereDeepProp
+     * @see or
+     * @see orDeepProp
+     */
+    where<P extends ClassPropNames<T>>(property: P, operator: QueryOperator, value: Partial<T[P]> | Persistent, aggregate?: boolean): this;
+    /**
+     * Matches all documents that the value of the deep property satisfies the condition
+     * in the operator parameter
+     * @param propertyPath the path to the property to be compared
+     * @param operator the operator to be used in the comparison. The available
+     * operators are: ==, !=, >, >=, < and <=
+     * @param value the value to be compared
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.whereDeepProp( 'address.street', '==', 'Main Street' )
+     * @see where
+     * @see or
+     * @see orDeepProp
+     */
+    whereDeepProp(propertyPath: PropPath<T>, operator: QueryOperator, value: PropPathType<T, typeof propertyPath>, aggregate?: boolean): this;
+    /**
+     * Matches all documents that the value of the property satisfies the condition
+     * in the operator parameter and aggregates the results to the previous query
+     * @param property the property to be compared
+     * @param operator the operator to be used in the comparison. The available
+     * operators are: ==, !=, >, >=, < and <=
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.where( 'name', '==', 'John' ).and( 'age', '>', 18 )
+     * @see andDeepProp
+     * @see where
+     * @see whereDeepProp
+     * @see or
+     * @see orDeepProp
+     */
+    and<P extends ClassPropNames<T>>(property: P, operator: QueryOperator, value: Partial<T[P]> | Persistent): this;
+    /**
+     * Matches all documents that the value of the deep property satisfies the condition
+     * in the operator parameter and aggregates the results to the previous query
+     * @param propertyPath the path to the property to be compared
+     * @param operator the operator to be used in the comparison. The available
+     * operators are: ==, !=, >, >=, < and <=
+     * @param value the value to be compared
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.whereDeepProp( 'address.street', '==', 'Main Street' ).andDeepProp( 'address.city', '==', 'New York' )
+     * @see and
+     * @see where
+     * @see whereDeepProp
+     * @see or
+     * @see orDeepProp
+     */
+    andDeepProp(propertyPath: PropPath<T>, operator: QueryOperator, value: PropPathType<T, typeof propertyPath>): this;
+    /**
+     * Matches all documents that the value of the property satisfies the condition
+     * in the operator parameter and aggregates the results to the previous query
+     * @param property the property to be compared
+     * @param operator the operator to be used in the comparison. The available
+     * operators are: ==, !=, >, >=, < and <=
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.or( 'name', '==', 'John' )
+     * query.or( 'age', '>', 18 )
+     * @see orDeepProp
+     * @see where
+     * @see whereDeepProp
+     */
+    or<P extends ClassPropNames<T>>(property: P, operator: QueryOperator, value: Partial<T[P]> | Persistent): this;
+    /**
+     * Matches all documents that the value of the deep property satisfies the condition
+     * in the operator parameter and aggregates the results to the previous query
+     * @param propertyPath the path to the property to be compared
+     * @param operator the operator to be used in the comparison. The available
+     * operators are: ==, !=, >, >=, < and <=
+     * @param value the value to be compared
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.orDeepProp( 'address.street', '==', 'Main Street' )
+     * @see or
+     * @see where
+     * @see whereDeepProp
+     */
+    orDeepProp(propertyPath: PropPath<T>, operator: QueryOperator, value: PropPathType<T, typeof propertyPath>): this;
+    /**
+     * Defines a where condition to match documents that are instances of the
+     * given class
+     * @param classId the class name or an instance to match
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.instanceOf( 'Person' )
+     * query.instanceOf( Person )
+     * query.instanceOf( Person ).where( 'age', '>', 18 )
+     */
+    instanceOf<U extends T>(classId: U | string): this;
+    /**
+     * Executes the query and returns the result
+     * @param limit the max amount of documents to retrieve. If not set, uses the
+     * last limit set or all the matching documents
+     * @returns a promise resolving to a collection of matched documents
+     * @example
+     * const namedJohn = await query.where( 'name', '==', 'John' ).get()
+     */
+    get<U extends T>(limit?: number): Promise<U[]>;
+    /**
+     * Limits the number of documents to retrieve
+     * @param maxDocs the max amount of documents to retrieve
+     * @returns this Query object to make chained calls possible
+     * @example
+     * query.where( 'name', '==', 'John' ).limit( 10 )
+     */
+    limit(maxDocs: number): this;
+    /**
+     * Orders the result set by a property.
+     * @param propertyName The name of the property to order by
+     * @param order The sort direction. Possible values are 'asc' and 'desc'
+     * @returns a chainable query object
+     * @example
+     * query.orderBy( 'name', 'asc' )
+     * query.orderBy( 'age', 'desc' )
+     */
+    orderBy<P extends ClassPropNames<T>>(propertyName: P, order?: QueryOrder): this;
+    /**
+     * Orders the result set by a deep property
+     *
+     * @param propertyPath The full path of the deep property. It should be
+     * 											separated by dots like person.name.firstName.
+     * @param order The sort direction. Possible values are 'asc' and 'desc'
+     * @returns a chainable query object
+     */
+    orderByDeepProp(propertyPath: string, order?: QueryOrder): this;
+    /**
+     * Returns the number of documents that match the query
+     * @returns a promise resolving to the number of documents that match the query
+     * @example
+     * const count = await query.where( 'name', '==', 'John' ).count()
+     */
+    count(): Promise<number>;
+    private queryObject;
+    private model;
+}

package/lib/store/model.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/store/store.d.ts

@@ -0,0 +1,62 @@
+import { Persistent } from '../persistent/persistent';
+import { DataSource } from './data-source';
+import { Model } from './model';
+/**
+ * The store is the main entry point for the data access layer.
+ * It provides methods to retrieve models for collections and subcollections.
+ * It also provides methods to populate property references with actual data from the store.
+ * You need to register a data source before using the store.
+ * @example
+ * // Register a data source
+ * Store.useDataSource( new FirestoreDataSource( firebase.firestore() ) )
+ * // Retrieve a model for a collection
+ * const model = Store.getModel( 'User' )
+ * // Retrieve a model for a subcollection
+ * const model = Store.getModelForSubCollection( user, 'Posts' )
+ * // Populate property references
+ * const user = await Store.populate( user )
+ */
+export declare class Store {
+    private constructor();
+    static error: {
+        shouldBeRegistered: string;
+    };
+    /**
+     * Registers a data source to be used by the store.
+     * You need to register a data source before using the store.
+     * @param dataSource the data source to be used by the store
+     */
+    static useDataSource(dataSource: DataSource): void;
+    /**
+     * The data source currently used by the store
+     * @returns the data source
+     */
+    static get dataSource(): DataSource;
+    /**
+     * Retrieves a model for a collection
+     * @param classId the class name or an instance of the document type stored in the collection
+     * @returns the model for the collection
+     */
+    static getModel<T extends Persistent>(classId: T | string): Model<T>;
+    /**
+     * Retrieves a model for a subcollection
+     * @param document the persistent object that owns the subcollection
+     * @param subCollection the name of the subcollection
+     * @returns the model for the subcollection
+     */
+    static getModelForSubCollection<T extends Persistent>(document: Persistent, subCollection: string): Model<T>;
+    /**
+     * Populates property references with actual data from the store.
+     * It will not retrieve data if the instance is already populated
+     * @param instance the data to be populated.
+     * @returns the populated instance
+     */
+    static populate<T extends Persistent | Persistent[]>(instance: T): Promise<T>;
+    /**
+     * Checks if an instance is populated
+     * @param instance the instance or array of instances to be checked
+     * @returns true if the instance is populated
+     */
+    static isPopulated<T extends Persistent>(instance: T | readonly T[]): boolean;
+    private static _dataSource;
+}

package/lib/store/store.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/utility-types.d.ts

@@ -0,0 +1,45 @@
+export type ClassMethodNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+export type ClassMethods<T> = Pick<T, ClassMethodNames<T>>;
+export type ClassPropNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type ClassProps<T> = Pick<T, ClassPropNames<T>>;
+export type SomeClassProps<T> = Partial<ClassProps<T>>;
+export type SomeClassPropNames<T> = Partial<ClassPropNames<T>>;
+export type ClassArrayPropNames<T> = {
+    [K in keyof T]: T[K] extends unknown[] | Readonly<unknown[]> ? K : never;
+}[keyof T];
+export type ClassArrayProps<T> = Pick<T, ClassArrayPropNames<T>>;
+export type Elements<T extends ReadonlyArray<any> | ArrayLike<any> | Record<any, any> | any> = T extends ReadonlyArray<any> ? T[number] : T extends ArrayLike<any> ? T[number] : T extends object ? T[keyof T] : never;
+export type UnderscoredProp<T> = `_${T & string}`;
+export interface Collection<T> {
+    [key: string | symbol]: T;
+}
+export declare type ClassPropNamesOfType<T, U> = {
+    [K in keyof T]: T[K] extends Function ? never : T[K] extends U ? K : never;
+}[keyof T];
+/**
+ * Makes K properties of T required and keeps the rest untouched
+ * @example
+ * type T = { a?: number, b?: string, c?: boolean, d: number }
+ * type R = Require<T, 'a' | 'b'>
+ * // R = { a: number, b: string, c?: boolean, d: number }
+ */
+export type Require<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+/*******************************************************************************
+ *
+ * SUB-PROPERTIES
+ *
+ *******************************************************************************/
+export type Primitive = string | number | bigint | boolean | undefined | symbol;
+type Decr = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+type Concat<T, U> = `${string & T}${string & U}`;
+export type PropPath<T extends {}, AllowedTypes = any, MaxDepth extends number = 3, Prefix = ''> = MaxDepth extends number ? {
+    [P in keyof T]: T[P] extends Function ? never : T[P] extends AllowedTypes ? T[P] extends Primitive | ArrayLike<any> ? Concat<Prefix, P> : Concat<Prefix, P> | PropPath<T[P] & {}, AllowedTypes, Decr[MaxDepth], `${Concat<Prefix, P>}.`> : never;
+}[keyof T] & string : never;
+export type PropPathType<T, Path, MaxDepth extends number = 2> = MaxDepth extends number ? Path extends keyof T ? T[Path] : Path extends `${infer PropName}.${infer SubPropName}` ? PropName extends keyof T ? PropPathType<T[PropName], SubPropName, Decr[MaxDepth]> : never : never : never;
+export {};

package/lib/types/utility-types.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/test-utils/test-person.d.ts

@@ -0,0 +1,33 @@
+export interface Name {
+    firstName: string;
+    secondName: string;
+}
+export interface Coordinates {
+    x: number;
+    y: number;
+}
+export interface TestPerson {
+    id: string;
+    name: Name;
+    age: number;
+    address: {
+        coordinates: Coordinates;
+        postalAddress: string;
+        senderMethod: () => void;
+    };
+    testMethod: () => void;
+    deepProp: {
+        l1: {
+            l2: {
+                l3: {
+                    l4: {
+                        l5: {
+                            l6: {};
+                        };
+                    };
+                };
+            };
+        };
+    };
+}
+export declare function samplePerson(): TestPerson;