ngx-sfc-common 0.0.1

package/lib/components/toggle-switcher/toggle-switcher.component.d.ts

@@ -0,0 +1,11 @@
+import { IToggleSwitcherModel } from './toggle-switcher.model';
+import * as i0 from "@angular/core";
+export declare class ToggleSwitcherComponent {
+    active: boolean;
+    leftModel: IToggleSwitcherModel;
+    rightModel: IToggleSwitcherModel;
+    onClick: () => boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleSwitcherComponent, "sfc-toggle-switcher", never, { "active": "active"; "leftModel": "leftModel"; "rightModel": "rightModel"; }, {}, never, never>;
+}

package/lib/components/toggle-switcher/toggle-switcher.model.d.ts

@@ -0,0 +1,4 @@
+export interface IToggleSwitcherModel {
+    label: string;
+    icon?: string;
+}

package/lib/components/tooltip/tooltip-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum TooltipType {
+    Hover = "hover",
+    Click = "click"
+}

package/lib/components/tooltip/tooltip.component.d.ts

@@ -0,0 +1,22 @@
+import { AfterContentInit, OnDestroy, OnInit } from '@angular/core';
+import { Position } from '../../enums';
+import { ResizeService } from '../../services';
+import { TooltipType } from './tooltip-type.enum';
+import * as i0 from "@angular/core";
+export declare class TooltipComponent implements OnInit, OnDestroy, AfterContentInit {
+    private resizeService;
+    private window;
+    value?: string;
+    tooltipType: TooltipType;
+    tooltipPosition: Position;
+    tooltipShow: boolean;
+    click(): void;
+    private _position;
+    private _resizeSubscription?;
+    constructor(resizeService: ResizeService, window: Window);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "[sfc-tooltip]", never, { "value": "sfc-tooltip"; "tooltipType": "tooltipType"; "tooltipPosition": "tooltipPosition"; "tooltipShow": "tooltipShow"; }, {}, never, ["*"]>;
+}

package/lib/constants/common.constants.d.ts

@@ -0,0 +1,5 @@
+export declare class CommonConstants {
+    static NOT_FOUND_INDEX: number;
+    static EMPTY_STRING: string;
+    static MOUSE_BUTTON_LEFT: number;
+}

package/lib/constants/date-time.constants.d.ts

@@ -0,0 +1,7 @@
+export declare class DateTimeConstants {
+    static DAYS_IN_WEEK: number;
+    static HOURS_IN_SHORT_TIME: number;
+    static MINUTES_IN_HOUR: number;
+    static DAYS_OF_WEEK: string[];
+    static DAYS_OF_WEEK_3: string[];
+}

package/lib/constants/index.d.ts

@@ -0,0 +1,3 @@
+export { CommonConstants } from './common.constants';
+export { DateTimeConstants } from './date-time.constants';
+export { UIConstants } from './ui.constants';

package/lib/constants/ui.constants.d.ts

@@ -0,0 +1,15 @@
+export declare class UIConstants {
+    static CSS_PIXELS: string;
+    static CSS_PERCENTAGE: string;
+    static CSS_DEGREES: string;
+    static CSS_EM: string;
+    static CSS_VISIBILITY_VISIBLE: string;
+    static CSS_VISIBILITY_HIDDEN: string;
+    static DEFAULT_THEME: string;
+    static DARK_THEME: string;
+    static CSS_WIDTH: string;
+    static CSS_LEFT: string;
+    static CSS_CLASS_FIXED: string;
+    static CSS_CLASS_BACKGROUND: string;
+    static CSS_CLASS_TOP: string;
+}

package/lib/directives/click-outside/click-outside.directive.d.ts

@@ -0,0 +1,23 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ClickOutsideEvent } from './click-outside.event';
+import * as i0 from "@angular/core";
+export declare class ClickOutsideDirective implements OnInit, OnDestroy {
+    private elementRef;
+    private document;
+    /**
+     * Toggler for checking ouside click event
+     */
+    listening: boolean;
+    /**
+     * Emitter for click event
+     */
+    action: EventEmitter<ClickOutsideEvent>;
+    private _clickSubscription?;
+    constructor(elementRef: ElementRef, document: Document);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private onClick;
+    private isDescendant;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[sfcClickOutside]", never, { "listening": "sfcClickOutside"; }, { "action": "action"; }, never>;
+}

package/lib/directives/click-outside/click-outside.event.d.ts

@@ -0,0 +1,4 @@
+export interface ClickOutsideEvent {
+    target: EventTarget | null;
+    value: boolean;
+}

package/lib/directives/component-size/component-size.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+import { ComponentSize } from '../../enums';
+import * as i0 from "@angular/core";
+export declare class ComponentSizeDirective {
+    private el;
+    set size(value: ComponentSize | null | undefined);
+    set customSize(value: number);
+    private get style();
+    constructor(el: ElementRef);
+    private getSizeValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentSizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComponentSizeDirective, "[sfcComponentSize]", never, { "size": "sfcComponentSize"; "customSize": "customSize"; }, {}, never>;
+}

package/lib/directives/index.d.ts

@@ -0,0 +1,7 @@
+export { ClickOutsideDirective } from './click-outside/click-outside.directive';
+export { ClickOutsideEvent } from './click-outside/click-outside.event';
+export { ShowHideElementDirective } from './show-hide-element/show-hide-element.directive';
+export { ThrowElementOnHoverDirective } from './throw-element-on-hover/throw-element-on-hover.directive';
+export { TemplateReferenceDirective } from './template-reference/template-reference.directive';
+export { MouseDownDirective } from './mouse-down/mouse-down.directive';
+export { ComponentSizeDirective } from './component-size/component-size.directive';

package/lib/directives/mouse-down/mouse-down.directive.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class MouseDownDirective {
+    /**
+     * Allowed mouse button
+     */
+    button: number;
+    action: EventEmitter<MouseEvent>;
+    onMouseDown($event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MouseDownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MouseDownDirective, "[sfcMouseDown]", never, { "button": "button"; }, { "action": "sfcMouseDown"; }, never>;
+}

package/lib/directives/show-hide-element/show-hide-element.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ShowHideElementDirective {
+    private el;
+    private readonly SHOW_HIDE_TRANSITION_DELAY_DEFAULT;
+    set showHideElement(show: boolean);
+    set delay(value: number);
+    private get style();
+    constructor(el: ElementRef);
+    private getTransitionValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowHideElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ShowHideElementDirective, "[sfcShowHideElement]", never, { "showHideElement": "sfcShowHideElement"; "delay": "delay"; }, {}, never>;
+}

package/lib/directives/template-reference/template-reference.directive.d.ts

@@ -0,0 +1,9 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TemplateReferenceDirective {
+    readonly template: TemplateRef<any>;
+    templateName: string;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateReferenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateReferenceDirective, "[sfcTemplateReference]", never, { "templateName": "sfcTemplateReference"; }, {}, never>;
+}

package/lib/directives/throw-element-on-hover/throw-element-on-hover.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ThrowElementOnHoverDirective {
+    private el;
+    throwValue?: number;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    private get style();
+    constructor(el: ElementRef);
+    private throw;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThrowElementOnHoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThrowElementOnHoverDirective, "[sfcThrowElementOnHover]", never, { "throwValue": "sfcThrowElementOnHover"; }, {}, never>;
+}

package/lib/enums/common.enums.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Component sizes
+ */
+export declare enum ComponentSize {
+    Small = "small",
+    Medium = "medium",
+    Large = "large",
+    Custom = "custom"
+}
+/**
+ * Type of sorting
+ */
+export declare enum SortingDirection {
+    Ascending = "ascending",
+    Descending = "descending"
+}
+/**
+ * UI classes
+ */
+export declare enum UIClass {
+    Active = "active",
+    Valid = "valid",
+    Invalid = "invalid",
+    Enabled = "enabled",
+    Disabled = "disabled",
+    Selected = "selected",
+    Empty = "empty",
+    Focus = "focus",
+    Open = "open",
+    Loading = "loading",
+    Removed = "removed",
+    Visible = "visible",
+    Hidden = "hidden",
+    Animated = "animated",
+    Expanded = "expanded",
+    Fixed = "fixed"
+}
+/**
+ * Position directions
+ */
+export declare enum Position {
+    Top = "top",
+    Bottom = "bottom",
+    Left = "left",
+    Right = "right"
+}
+/**
+ * CSS Media limits
+ */
+export declare enum MediaLimits {
+    Laptop = 1200,
+    Tablet = 767,
+    Phone = 430
+}
+/**
+ * Direction types
+ */
+export declare enum Direction {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}

package/lib/enums/index.d.ts

@@ -0,0 +1 @@
+export { SortingDirection, UIClass, ComponentSize, Position, MediaLimits, Direction } from './common.enums';

package/lib/ngx-sfc-common.module.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./directives/click-outside/click-outside.directive";
+import * as i2 from "./directives/show-hide-element/show-hide-element.directive";
+import * as i3 from "./directives/throw-element-on-hover/throw-element-on-hover.directive";
+import * as i4 from "./directives/template-reference/template-reference.directive";
+import * as i5 from "./directives/mouse-down/mouse-down.directive";
+import * as i6 from "./directives/component-size/component-size.directive";
+import * as i7 from "./components/button/button.component";
+import * as i8 from "./components/tooltip/tooltip.component";
+import * as i9 from "./components/delimeter/delimeter.component";
+import * as i10 from "./components/loader/bounce/bounce-loader.component";
+import * as i11 from "./components/loader/circle/circle-loader.component";
+import * as i12 from "./components/modal/modal.component";
+import * as i13 from "./components/modal/directive/modal-open-on-click.directive";
+import * as i14 from "./components/modal/header/default/default-modal-header.component";
+import * as i15 from "./components/modal/footer/default/default-modal-footer.component";
+import * as i16 from "./components/hamburger/hamburger.component";
+import * as i17 from "./components/dots/dots.component";
+import * as i18 from "./components/toggle-switcher/toggle-switcher.component";
+import * as i19 from "./components/checkmark/checkmark.component";
+import * as i20 from "@angular/common";
+import * as i21 from "@angular/platform-browser/animations";
+export declare class NgxSfcCommonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSfcCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSfcCommonModule, [typeof i1.ClickOutsideDirective, typeof i2.ShowHideElementDirective, typeof i3.ThrowElementOnHoverDirective, typeof i4.TemplateReferenceDirective, typeof i5.MouseDownDirective, typeof i6.ComponentSizeDirective, typeof i7.ButtonComponent, typeof i8.TooltipComponent, typeof i9.DelimeterComponent, typeof i10.BounceLoaderComponent, typeof i11.CircleLoaderComponent, typeof i12.ModalComponent, typeof i13.ModalOpenOnClickDirective, typeof i14.DefaultModalHeaderComponent, typeof i15.DefaultModalFooterComponent, typeof i16.HamburgerComponent, typeof i17.DotsComponent, typeof i18.ToggleSwitcherComponent, typeof i19.CheckmarkComponent], [typeof i20.CommonModule, typeof i21.BrowserAnimationsModule], [typeof i1.ClickOutsideDirective, typeof i2.ShowHideElementDirective, typeof i3.ThrowElementOnHoverDirective, typeof i4.TemplateReferenceDirective, typeof i5.MouseDownDirective, typeof i6.ComponentSizeDirective, typeof i7.ButtonComponent, typeof i8.TooltipComponent, typeof i9.DelimeterComponent, typeof i10.BounceLoaderComponent, typeof i11.CircleLoaderComponent, typeof i12.ModalComponent, typeof i13.ModalOpenOnClickDirective, typeof i14.DefaultModalHeaderComponent, typeof i15.DefaultModalFooterComponent, typeof i16.HamburgerComponent, typeof i17.DotsComponent, typeof i18.ToggleSwitcherComponent, typeof i19.CheckmarkComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxSfcCommonModule>;
+}

package/lib/services/document-ref.service.d.ts

@@ -0,0 +1,43 @@
+import { ClassProvider, FactoryProvider, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Create a new injection token for injecting the Document into a component.
+ */
+export declare const DOCUMENT: InjectionToken<Document>;
+/**
+ * Define abstract class for obtaining reference to the global Document object.
+ */
+export declare abstract class DocumentRef {
+    get nativeDocument(): Document | Object;
+}
+/**
+ * Define class that implements the abstract class and returns the native Document object.
+ */
+export declare class BrowserDocumentRef extends DocumentRef {
+    constructor();
+    /**
+     * @returns Document object
+     */
+    get nativeDocument(): Document | Object;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserDocumentRef, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserDocumentRef>;
+}
+/**
+ * Create an factory function that returns the native Document object.
+ * @param browserDocumentRef Native Document object
+ * @param platformId id of platform
+ * @returns type of platform of empty object
+ */
+export declare function documentFactory(browserDocumentRef: BrowserDocumentRef, platformId: Object): Document | Object;
+/**
+ * Create a injectable provider for the DocumentRef token that uses the BrowserDocumentRef class.
+ */
+export declare const browserDocumentProvider: ClassProvider;
+/**
+ * Create an injectable provider that uses the DocumentFactory function for returning the native Document object.
+ */
+export declare const documentProvider: FactoryProvider;
+/**
+ * Create an array of providers.
+ */
+export declare const DOCUMENT_PROVIDERS: (ClassProvider | FactoryProvider)[];

package/lib/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './document-ref.service';
+export * from './window-ref.service';
+export * from './resize.service';

package/lib/services/resize.service.d.ts

@@ -0,0 +1,32 @@
+import { EventManager } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ResizeService {
+    private eventManager;
+    /**
+       * Width of window
+       */
+    windowWidth: any;
+    /**
+     * Makes resizeSubject become Observable
+     * @returns Observable of resizeSubject
+     */
+    get onResize$(): Observable<Window>;
+    /**
+     * Subject of 'resize' event
+     */
+    private resizeSubject;
+    constructor(eventManager: EventManager);
+    /**
+     * Handler of 'resize' event. Passes data throw resizeSubject
+     * @param event Event Object of 'resize' event
+     */
+    private onResize;
+    /**
+     * Handler of 'onload' event. Defines the width of window
+     * @param event Event Object of 'onload' event
+     */
+    private onLoaded;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeService>;
+}

package/lib/services/window-ref.service.d.ts

@@ -0,0 +1,43 @@
+import { ClassProvider, FactoryProvider, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Create a new injection token for injecting the window into a component.
+ */
+export declare const WINDOW: InjectionToken<unknown>;
+/**
+ * Define abstract class for obtaining reference to the global window object.
+ */
+export declare abstract class WindowRef {
+    get nativeWindow(): Window | Object;
+}
+/**
+ * Define class that implements the abstract class and returns the native window object.
+ */
+export declare class BrowserWindowRef extends WindowRef {
+    constructor();
+    /**
+     * @returns window object
+     */
+    get nativeWindow(): Window | Object;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserWindowRef, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserWindowRef>;
+}
+/**
+ * Create an factory function that returns the native window object.
+ * @param browserWindowRef Native window object
+ * @param platformId id of platform
+ * @returns type of platform of empty object
+ */
+export declare function windowFactory(browserWindowRef: BrowserWindowRef, platformId: Object): Window | Object;
+/**
+ * Create a injectable provider for the WindowRef token that uses the BrowserWindowRef class.
+ */
+export declare const browserWindowProvider: ClassProvider;
+/**
+ * Create an injectable provider that uses the windowFactory function for returning the native window object.
+ */
+export declare const windowProvider: FactoryProvider;
+/**
+ * Create an array of providers.
+ */
+export declare const WINDOW_PROVIDERS: (ClassProvider | FactoryProvider)[];

package/lib/utils/collections.utils.d.ts

@@ -0,0 +1,135 @@
+import { SortingDirection } from "../enums";
+/**
+ * Return true if collection not empty
+ * @param collection Array of items
+ * @returns True if collection not empty
+ */
+export declare function any<T>(collection: Array<T> | null | undefined): boolean;
+/**
+ * Return true if collection has such value
+ * @param collection Array of items
+ * @param value Value to check
+ * @returns True if found value in collection
+ */
+export declare function hasItem<T>(collection: Array<T>, value: T): boolean;
+/**
+ * Return true if collection has such value by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define check logic
+ * @returns True if found value in collection
+ */
+export declare function hasItemBy<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean;
+/**
+ * Return true if collection of objects has such value as object
+ * @param collection Array of objects
+ * @param property Property name
+ * @param value Value to check
+ * @returns True if found value in collection
+ */
+export declare function hasObjectItem<T>(collection: Array<any>, // TODO <-- Array<T>
+property: string, value: T): boolean;
+/**
+ * Return value from collection by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define search logic
+ * @returns Value from collection
+ */
+export declare function firstOrDefault<T>(collection: Array<T> | null | undefined, predicate: (item: T) => boolean): T | undefined;
+/**
+ * Return first item from collection
+ * @param collection Array of items
+ * @returns First value from collection
+ */
+export declare function firstItem<T>(collection: Array<T>): T | null | undefined;
+/**
+ * Return last item from collection
+ * @param collection Array of items
+ * @returns Last value from collection
+ */
+export declare function lastItem<T>(collection: Array<T>): T | null | undefined;
+/**
+ * Return True if all values match predicate function
+ * @param collection Array of objects
+ * @param predicate Function to define check logic
+ * @returns True if all values match predicate
+ */
+export declare function all<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean;
+/**
+ * Return items from collection by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define search logic
+ * @returns Values from collection
+ */
+export declare function where<T>(collection: Array<T>, predicate: (item: T) => boolean): Array<T> | null | undefined;
+/**
+ * Return sliced collection by page number and page size
+ * @param collection Array of items
+ * @param page Page number
+ * @param size Page size
+ * @returns Sliced collection
+ */
+export declare function skip<T>(collection: Array<T>, page: number, size: number): Array<T>;
+/**
+ * Return sorted collection of objects by property
+ * @param collection Array of items
+ * @param property Property name
+ * @param direction Sorting direction
+ * @returns Sorted collection
+ */
+export declare function sortBy<T>(collection: Array<T>, property: string, direction: SortingDirection): Array<T>;
+/**
+ * Return sorted collection of objects by path
+ * @param collection Array of items
+ * @param path Path to property
+ * @param direction Sorting direction
+ * @returns Sorted collection
+ */
+export declare function sortByPath<T>(collection: Array<T>, path: string, direction: SortingDirection): Array<T>;
+/**
+ * Return collection without matches
+ * @param collection Array of items
+ * @returns Collection without matches
+ */
+export declare function distinct<T>(collection: Array<T>): Array<T>;
+/**
+ * Return sum value from collection items by map function
+ * @param collection Array of items
+ * @param select Map function
+ * @returns Sum value of colection items
+ */
+export declare function sum<T>(collection: Array<T>, select: (item: T) => number): number;
+/**
+ * Return max value from collection items by map function
+ * @param collection Array of items
+ * @param select Map function
+ * @returns Max value of collection items
+ */
+export declare function max<T>(collection: Array<T>, select: (item: T) => number): number;
+/**
+ * Delete items from collection by predicate
+ * @param collection Array of items
+ * @param predicate Function to define remove logic
+ */
+export declare function remove<T>(collection: Array<T>, predicate: (item: T) => boolean): void;
+/**
+ * Add item to collection
+ * @param collection Array of items
+ * @param item New item
+ * @param predicate Function to define if allowed to add new item
+ * @returns True if successfully added
+ */
+export declare function addItem<T>(collection: Array<T>, item: T, predicate: (item: T) => boolean): boolean;
+/**
+ * Delete item from collection by predicate
+ * @param collection Array of items
+ * @param predicate Function to define remove logic
+ * @returns True if successfully removed
+ */
+export declare function removeItem<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean;
+export declare function updateItem<T>(collection: Array<T>, predicate: (item: T) => boolean, newItem: T): Array<T> | null;
+/**
+ * Return collection or empty if collection is not defined
+ * @param collection Array of items
+ * @returns Collection or empty
+ */
+export declare function getCollectionOrEmpty<T>(collection: Array<T>): Array<T>;

package/lib/utils/common.utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Return true if value defined
+ * @param value Value to check
+ * @returns True if value is not null and defined
+ */
+export declare function isDefined<T>(value: T | undefined | null): boolean;
+/**
+ * Return true if value is object
+ * @param value Value to check
+ * @returns True if value is object
+ */
+export declare function isObject(value: any): boolean;
+/**
+ * Return true if data is observable
+ * @param data Object to check
+ * @returns True if data is observable
+ */
+export declare function isAsyncData(data: any): boolean;
+/**
+ * Return extended object with new property
+ * @param obj Object to extend by property
+ * @param property New property name
+ * @param value Value for new property
+ * @returns Extended object with new property
+ */
+export declare function addPropertyToObject(obj: any, property: string, value?: any): any;
+/**
+ * Remove property from object
+ * @param obj Object for removing property
+ * @param property Property name to remove
+ */
+export declare function removePropertyFromObject(obj: any, property: string): void;
+/**
+  * Deep merge object with others
+  * @param target Object to merge
+  * @param sources
+  */
+/**
+ * Deep merge object with others
+ * @param target  Object to merge
+ * @param sources Objects to be merged with target
+ * @returns Merged object
+ */
+export declare function mergeDeep(target: any, ...sources: any[]): any;
+/**
+ * Get type's property name safety
+ * @param name KeyOf property
+ * @returns Type's property name
+ */
+export declare const nameof: <T>(name: keyof T) => keyof T;