danholibraryjs 1.7.0 → 1.10.0

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

package/dist/Classes/Events/Event.js

@@ -53,7 +53,7 @@ class Event {
      */
     on(listener, prepend = false) {
         if (this.limit > 0 && this._listeners.length + 1 > this.limit) {
-            throw new Error(`Event limit, ${this.limit}, reached for event ${this.name}!`);
+            throw new Error(`Event limit, ${this.limit}, reached for event ${this.name.toString()}!`);
         }
         if (prepend)
             this._listeners = [listener, ...this._listeners];

package/dist/Classes/Events/EventCollection.js

@@ -99,7 +99,7 @@ class EventCollection {
         }
         const event = this.get(eventName);
         if (!event)
-            throw new Error(`Unknown event, ${eventName}!`);
+            throw new Error(`Unknown event, ${eventName.toString()}!`);
         event.limit = limit;
         this._events.set(eventName, event);
         return this;

package/dist/Classes/Events/EventEmitter.d.ts

@@ -4,6 +4,30 @@ import { BaseEvent, EventHandler } from '../../Types';
  * @borrows EventCollection
  * @borrows BaseEvent
  * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
 export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
     /**@param events Map<name: string, handlers: EventHandler[]>*/
@@ -16,21 +40,21 @@ export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>>
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this;
+    on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<Events>;
     /**
      * Adds listener to event collection, and runs listener once when event is emitted
      * @param event Event to handle
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this;
+    once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<Events>;
     /**
      * Removes listener(s) from event
      * @param event Event to get collection of listeners | "all"
      * @param listener If left null, removes all listeners tied to event, else only removes listener from event
      * @returns this
      */
-    off<Return extends any, Event extends keyof Events>(event?: Event | 'all', listener?: EventHandler<Events, Event, Return>): this;
+    off<Return extends any, Event extends keyof Events>(event?: Event | 'all', listener?: EventHandler<Events, Event, Return>): EventEmitter<Events>;
     /**
      * Emits event and runs all listeners tied to event
      * @param event Event to emit
@@ -45,6 +69,6 @@ export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>>
      * @param limit Limit of events to keep. If you want to limit amount of events saved, use 'all'.
      * @returns this with the new limit
      */
-    limit<Event extends keyof Events>(event: 'all' | Event, limit: number): this;
+    limit<Event extends keyof Events>(event: 'all' | Event, limit: number): EventEmitter<Events>;
 }
 export default EventEmitter;

package/dist/Classes/Events/EventEmitter.js

@@ -10,6 +10,30 @@ const EventCollection_1 = __importDefault(require("./EventCollection"));
  * @borrows EventCollection
  * @borrows BaseEvent
  * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
 class EventEmitter {
     /**@param events Map<name: string, handlers: EventHandler[]>*/

package/dist/Classes/Time/Date.d.ts

@@ -1,16 +1,16 @@
 import { BetterOmit, PartialExcept, LongMonth, LongDay, ShortDay, ShortMonth } from "../../Types";
 import TimeProperties from "./TimeProperties";
 import TimeSpan, { TimeSpanFormat } from "./TimeSpan";
-declare type Data = PartialExcept<BetterOmit<TimeProperties<true>, 'weeks'>, 'years' | 'months'>;
-declare type Double = `${number}${number}`;
-declare type Quadruple = `${Double}${Double}`;
-declare type DateFormat = `${Double}/${Double}/${Quadruple}`;
+type Data = PartialExcept<BetterOmit<TimeProperties<true>, 'weeks'>, 'years' | 'months'>;
+type Double = `${number}${number}`;
+type Quadruple = `${Double}${Double}`;
+type DateFormat = `${Double}/${Double}/${Quadruple}`;
 /**
  * Type used to construct DanhoDate.
  * @Data Partial TimeProperties except years & months
  * @DateFormat string as dd/MM/yyyy
  */
-export declare type DanhoDateConstructor = Data | DateFormat | number | Date;
+export type DanhoDateConstructor = Data | DateFormat | number | Date;
 declare class DanhoDate {
     /**
      * Returns the value of the current irl time

package/dist/Classes/Time/Time.d.ts

@@ -1,8 +1,8 @@
 import { LongMonth } from "../../Types/Date";
 /** '2s' or 2000 */
-export declare type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
-export declare type TimeString = `${number}${TimeUnit}`;
-export declare type TimeDelay = number | TimeString;
+export type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
+export type TimeString = `${number}${TimeUnit}`;
+export type TimeDelay = number | TimeString;
 export declare const ValidTime: RegExp;
 /**
  * Converts input into milliseconds

package/dist/Classes/Time/TimeProperties.d.ts

@@ -1,3 +1,3 @@
-declare type TimeKeys = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
-export declare type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>;
+type TimeKeys = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
+export type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>;
 export default TimeProperties;

package/dist/Classes/Time/TimeSpan.d.ts

@@ -4,7 +4,7 @@ import TimeProperties from "./TimeProperties";
 /**
  * What properties to include when using TimeSpan.toString(format: TimeSpanFormat): string
  */
-export declare type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>;
+export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>;
 /**
  * Timespan between 2 dates.
  * @borrows TimeSpanValue

package/dist/Classes/index.d.ts

@@ -1,2 +1,3 @@
 export * from './Events';
 export * from './Time';
+export * from './store';

package/dist/Classes/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Events"), exports);
 __exportStar(require("./Time"), exports);
+__exportStar(require("./store"), exports);

package/dist/Classes/store.d.ts

@@ -0,0 +1,79 @@
+import { Arrayable } from "../Types";
+import { EventEmitter } from "./Events";
+export type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State;
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ *
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ *
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ *
+ * Reducer functions can be removed using Store.off('action', reducer);
+ *
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ *
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ *
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ *
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ *
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, {
+ *          id: Math.random().toString(),
+ *          text,
+ *          completed: false
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ *
+ *      return state.map(todo => (
+ *          todo.id === id ? {
+ *              ...todo,
+ *              completed: force === undefined ? !todo.completed : force
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ *
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ *
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ *
+ * store.dispatch('create', 'Make store!');
+ *
+ * ```
+ */
+export declare class Store<State extends object, ActionTypes extends Record<string, any[]>, Actions extends {
+    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
+} = {
+    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
+}> extends EventEmitter<Record<keyof Actions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
+    constructor(state: State, actions?: {
+        [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>>;
+    });
+    private _state;
+    get state(): State;
+    dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State;
+}
+export default Store;

package/dist/Classes/store.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+const Events_1 = require("./Events");
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ *
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ *
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ *
+ * Reducer functions can be removed using Store.off('action', reducer);
+ *
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ *
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ *
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ *
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ *
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, {
+ *          id: Math.random().toString(),
+ *          text,
+ *          completed: false
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ *
+ *      return state.map(todo => (
+ *          todo.id === id ? {
+ *              ...todo,
+ *              completed: force === undefined ? !todo.completed : force
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ *
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ *
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ *
+ * store.dispatch('create', 'Make store!');
+ *
+ * ```
+ */
+class Store extends Events_1.EventEmitter {
+    constructor(state, actions = {}) {
+        super(new Map(...Object.entries(actions).map(([action, reducers]) => [action, reducers])));
+        this._state = state;
+    }
+    _state;
+    get state() {
+        return this._state;
+    }
+    dispatch(action, ...args) {
+        const previous = { ...this._state };
+        this._state = super.emit(action, ...args).reduce((state, returned) => ({ ...state, ...returned }), this.state);
+        super.emit('stateChange', ...[previous, this.state]);
+        return this.state;
+    }
+}
+exports.Store = Store;

package/dist/Extensions/Array.d.ts

@@ -1,5 +1,5 @@
 export {};
-declare type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
+type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
 declare global {
     interface Array<T> {
         /**
@@ -27,5 +27,12 @@ declare global {
          * @param i Index of item
          */
         index(i: number): T;
+        /**
+         * For every x in array, execute callback
+         * @param every i.e every 2nd item in array
+         * @param callback Function to execute
+         * @returns Array of results
+         */
+        nth<U>(every: number, callback: (collection: Array<T>, index: number, self: this) => U): Array<U>;
     }
 }

package/dist/Extensions/Array.js

@@ -1,26 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-Array.prototype.add = function (...items) {
+exports.ArrayExtensions = void 0;
+function add(...items) {
     this.push(...items);
     return this;
-};
-Array.prototype.update = function (old, updated) {
-    const item = typeof old === 'number' ? this[old] : typeof old === 'function' ? this.find(old) : old;
+}
+Array.prototype.add = add;
+function update(old, updated) {
+    const item = typeof old === 'number' ? this[old]
+        : typeof old === 'function' ? this.find(old)
+            : old;
     if (!item)
         throw new Error('Old was not found in array!');
     const index = this.indexOf(item);
     return this[index] = updated;
-};
-Array.prototype.remove = function (value) {
+}
+Array.prototype.update = update;
+function remove(value) {
     const index = typeof value === 'number' ? value : this.indexOf(value);
     if (index > -1)
         this.splice(index, 1);
     return this;
-};
-Array.prototype.random = function () {
+}
+Array.prototype.remove = remove;
+function random() {
     const randomIndex = Math.round(Math.random() * this.length);
     return this[randomIndex];
-};
-Array.prototype.index = function (i) {
+}
+Array.prototype.random = random;
+function index(i) {
     return this[i < 0 ? this.length + i : i];
+}
+Array.prototype.index = index;
+function nth(every, callback) {
+    const result = new Array();
+    let collection = new Array();
+    for (let i = 0; i < this.length; i++) {
+        collection.push(this[i]);
+        if (i % every === 0) {
+            result.push(callback(this[i], i, collection, this));
+            collection = new Array();
+        }
+    }
+    return result;
+}
+Array.prototype.nth = nth;
+exports.ArrayExtensions = {
+    add, update, remove,
+    random, index, nth
+};
+Array.prototype.nth = function (every, callback) {
+    const result = new Array();
+    let collection = new Array();
+    for (let i = 0; i < this.length; i++) {
+        collection.push(this[i]);
+        if (i % every === 0) {
+            result.push(callback(collection, i, this));
+            collection = new Array();
+        }
+    }
+    return result;
 };

package/dist/Extensions/Document.d.ts

@@ -0,0 +1,27 @@
+import { IElement } from "../Types";
+declare global {
+    interface Document {
+        /**
+         * Creates an element like Document#createElement, however with construction options to assign values in construction instead of after construction.
+         * @param tagName HTMLElement tag name
+         * @param options Construction options, instead of assigning values after construction
+         * @param children Child elements
+         */
+        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]>, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+        createElementFromString<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
+    }
+    interface HTMLCollection {
+        /**
+         * Converts HTMLCollection to Element[]
+         */
+        array(): Element[];
+    }
+}
+declare function createElement<Tag extends keyof HTMLElementTagNameMap>(this: Document, tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]> | string, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+declare function createElementFromString<Tag extends keyof HTMLElementTagNameMap>(this: Document, html: string, tag?: Tag): HTMLElementTagNameMap[Tag];
+export declare const DocumentExtensions: {
+    createElement: typeof createElement;
+    createElementFromString: typeof createElementFromString;
+};
+export {};

package/dist/Extensions/Document.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentExtensions = void 0;
+function createElement(tagName, options, ...children) {
+    const element = Object.assign(document.createElement(tagName), typeof options === 'string' ? {} : options);
+    children ??= typeof options === 'string' ? [options] : [];
+    typeof options === 'string' && children.unshift(options);
+    if (!children.length)
+        return element;
+    else if (typeof children === 'string')
+        element.innerHTML = children;
+    else if (children instanceof Array)
+        children.forEach(child => (typeof child === 'string' ?
+            element.innerHTML += child :
+            element.appendChild(child)));
+    else
+        element.appendChild(children);
+    return element;
+}
+Document.prototype.createProperElement = createElement;
+function createElementFromString(html, tag) {
+    if (!html.startsWith(`<${tag}`))
+        html = `<${tag}>${html}</${tag}>`;
+    return new DOMParser().parseFromString(html, 'text/html').body.firstElementChild;
+}
+Document.prototype.createElementFromString = createElementFromString;
+HTMLCollection.prototype.array = function () {
+    return Array.from(this);
+};
+exports.DocumentExtensions = {
+    createElement, createElementFromString
+};

package/dist/Extensions/Function.d.ts

@@ -0,0 +1,14 @@
+declare global {
+    interface Function {
+        /**
+         * Checks if obj is a function
+         * @param obj Object to check
+         */
+        is(obj: any): obj is Function;
+    }
+}
+declare function is(obj: any): obj is Function;
+export declare const FunctionExtensions: {
+    is: typeof is;
+};
+export {};

package/dist/Extensions/Function.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionExtensions = void 0;
+function is(obj) {
+    return typeof obj === 'function';
+}
+Function.is = is;
+exports.FunctionExtensions = {
+    is
+};

package/dist/Extensions/Map.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Map<K, V> {
         /**
@@ -36,3 +35,20 @@ declare global {
         includes(value: V, fromIndex?: number): boolean;
     }
 }
+declare function array<K, V>(this: Map<K, V>): Array<[K, V]>;
+declare function map<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV>;
+declare function filter<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V>;
+declare function keyArr<K, V>(this: Map<K, V>): Array<K>;
+declare function valueArr<K, V>(this: Map<K, V>): Array<V>;
+declare function find<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): [K, V] | undefined;
+declare function includes<K, V>(this: Map<K, V>, item: V, fromIndex?: number): boolean;
+export declare const MapExtensions: {
+    array: typeof array;
+    map: typeof map;
+    filter: typeof filter;
+    keyArr: typeof keyArr;
+    valueArr: typeof valueArr;
+    find: typeof find;
+    includes: typeof includes;
+};
+export {};

package/dist/Extensions/Map.js

@@ -1,31 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-Map.prototype.array = function () {
+exports.MapExtensions = void 0;
+function array() {
     let result = new Array();
     for (const kvp of this) {
         result.push(kvp);
     }
     return result;
-};
-Map.prototype.map = function (callback) {
+}
+Map.prototype.array = array;
+function map(callback) {
     return this.array()
         .map(([k, v], i) => callback(v, k, i, this))
         .reduce((map, [key, value]) => map.set(key, value), new Map());
-};
-Map.prototype.filter = function (callback) {
+}
+Map.prototype.map = map;
+function filter(callback) {
     return this.array()
         .filter(([k, v], i) => callback(v, k, i, this))
         .reduce((map, [key, value]) => map.set(key, value), new Map());
-};
-Map.prototype.keyArr = function () {
+}
+Map.prototype.filter = filter;
+function keyArr() {
     return this.array().map(([k]) => k);
-};
-Map.prototype.valueArr = function () {
+}
+Map.prototype.keyArr = keyArr;
+function valueArr() {
     return this.array().map(([_, v]) => v);
-};
-Map.prototype.find = function (callback) {
+}
+Map.prototype.valueArr = valueArr;
+function find(callback) {
     return this.array().find(([k, v], i) => callback(v, k, i, this));
-};
-Map.prototype.includes = function (item, fromIndex) {
+}
+Map.prototype.find = find;
+function includes(item, fromIndex) {
     return this.valueArr().includes(item, fromIndex);
+}
+Map.prototype.includes = includes;
+exports.MapExtensions = {
+    array, map, filter, keyArr, valueArr, find, includes
 };

package/dist/Extensions/Object/index.d.ts

@@ -0,0 +1,49 @@
+import { ValueOf } from "../../Types";
+import { Properties } from "./properties";
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Destructures object into array of [property, value]
+         * @param from Object to destruct
+         */
+        array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
+        /**
+         * Omits properties from object, but for some reason the correct term is "extract"
+         * @param from Object to extract properties from
+         * @param props Properties to extract/Omit
+         */
+        extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+        /**
+         * Pick properties from object, but for some reason the correct term is "exclude"
+         * @param from Object to exclude properties from
+         * @param props Properties to exclude/pick
+         */
+        exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+        /**
+         * Returns true if object is empty
+         * @param obj Object to check
+         */
+        isNullOrUndefined(obj: any): obj is null | undefined;
+        /**
+         * Destructures object into array of property keys
+         * @param from Object to destruct
+         */
+        keysOf<From extends {} = {}>(from: From): Array<keyof From>;
+        omit<From extends {}, Exclude extends keyof From>(from: From, ...exclude: Exclude[]): Omit<From, Exclude>;
+        properties: Properties;
+    }
+}
+declare function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]>;
+declare function extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+declare function exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+declare function isNullOrUndefined(obj: any): obj is null | undefined;
+declare function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From>;
+export declare const ObjectExtensions: {
+    properties: Properties;
+    array: typeof array;
+    extract: typeof extract;
+    exclude: typeof exclude;
+    isNullOrUndefined: typeof isNullOrUndefined;
+    keysOf: typeof keysOf;
+};
+export {};