@amazon/vinyl-util 1.0.0

package/dist/types/ts3.7/util/fun/flow.d.ts

@@ -0,0 +1,38 @@
+import { MaybePromise } from '../type';
+/**
+ * Creates a function that is the composition of the provided functions.
+ * Each function consumes the return value of the function that follows.
+ */
+export declare function flow<A, B>(f1: (a: A) => B): (a: A) => B;
+export declare function flow<A, B, C>(f1: (a: A) => B, f2: (b: B) => C): (a: A) => C;
+export declare function flow<A, B, C, D>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D): (a: A) => D;
+export declare function flow<A, B, C, D, E>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E): (a: A) => E;
+export declare function flow<A, B, C, D, E, F>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F): (a: A) => F;
+/**
+ * Creates a function that is the composition of the provided functions.
+ * Each function consumes the return value of the function that precedes.
+ */
+export declare function flowRight<A, B>(f1: (a: A) => B): (a: A) => B;
+export declare function flowRight<A, B, C>(f1: (b: B) => C, f2: (a: A) => B): (a: A) => C;
+export declare function flowRight<A, B, C, D>(f1: (c: C) => D, f2: (b: B) => C, f3: (a: A) => B): (a: A) => D;
+export declare function flowRight<A, B, C, D, E>(f1: (d: D) => E, f2: (c: C) => D, f3: (b: B) => C, f4: (a: A) => B): (a: A) => E;
+export declare function flowRight<A, B, C, D, E, F>(f1: (e: E) => F, f2: (d: D) => E, f3: (c: C) => D, f4: (b: B) => C, f5: (a: A) => B): (a: A) => F;
+/**
+ * Creates a function that is the composition of the provided async functions.
+ * Each function consumes the return value of the function that follows.
+ */
+export declare function flowAsync<A, B>(f1: (a: A) => MaybePromise<B>): (a: A) => Promise<B>;
+export declare function flowAsync<A, B, C>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>): (a: A) => Promise<C>;
+export declare function flowAsync<A, B, C, D>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>, f3: (c: C) => MaybePromise<D>): (a: A) => Promise<D>;
+export declare function flowAsync<A, B, C, D, E>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>, f3: (c: C) => MaybePromise<D>, f4: (d: D) => MaybePromise<E>): (a: A) => Promise<E>;
+export declare function flowAsync<A, B, C, D, E, F>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>, f3: (c: C) => MaybePromise<D>, f4: (d: D) => MaybePromise<E>, f5: (e: E) => MaybePromise<F>): (a: A) => Promise<F>;
+/**
+ * Creates a function that is the composition of the provided async functions.
+ * Each function consumes the return value of the function that precedes.
+ */
+export declare function flowRightAsync<A, B>(f1: (a: A) => MaybePromise<B>): (a: A) => Promise<B>;
+export declare function flowRightAsync<A, B, C>(f1: (b: B) => MaybePromise<C>, f2: (a: A) => MaybePromise<B>): (a: A) => Promise<C>;
+export declare function flowRightAsync<A, B, C, D>(f1: (c: C) => MaybePromise<D>, f2: (b: B) => MaybePromise<C>, f3: (a: A) => MaybePromise<B>): (a: A) => Promise<D>;
+export declare function flowRightAsync<A, B, C, D, E>(f1: (d: D) => MaybePromise<E>, f2: (c: C) => MaybePromise<D>, f3: (b: B) => MaybePromise<C>, f4: (a: A) => MaybePromise<B>): (a: A) => Promise<E>;
+export declare function flowRightAsync<A, B, C, D, E, F>(f1: (e: E) => MaybePromise<F>, f2: (d: D) => MaybePromise<E>, f3: (c: C) => MaybePromise<D>, f4: (b: B) => MaybePromise<C>, f5: (a: A) => MaybePromise<B>): (a: A) => Promise<F>;
+//# sourceMappingURL=flow.d.ts.map

package/dist/types/ts3.7/util/fun/function.d.ts

@@ -0,0 +1,5 @@
+/**
+ * No-op, does nothing.
+ */
+export declare function noop(..._: any[]): void;
+//# sourceMappingURL=function.d.ts.map

package/dist/types/ts3.7/util/fun/memoize.d.ts

@@ -0,0 +1,24 @@
+import { Fun } from '../../util/type';
+export interface MemoizedFunction {
+    clear(): void;
+}
+/**
+ * Returns a wrapper function where when called, retains the return value of `inner`, returning that
+ * value on consecutive calls without invoking `inner` again.
+ *
+ * @param inner The function to memoize results.
+ * @return Returns a memoized function with a `clear` method to reset the cached value.
+ */
+export declare function memoize<T extends () => any>(inner: T): MemoizedFunction & T;
+/**
+ * Returns a wrapper function where when called, retains the return value of `inner`, returning that
+ * value on consecutive calls without invoking `inner` again.
+ *
+ * @param inner The function to memoize results.
+ * @param keyProvider When more than one parameter is expected, a keyProvider is required, which
+ * returns a unique key given the arguments provided to the memoized function.
+ * @param capacity
+ * @return Returns a memoized function with a `clear` method to reset the cache.
+ */
+export declare function memoize<T extends Fun>(inner: T, keyProvider: (...args: Parameters<T>) => any, capacity?: number): MemoizedFunction & T;
+//# sourceMappingURL=memoize.d.ts.map

package/dist/types/ts3.7/util/fun/throttle.d.ts

@@ -0,0 +1,34 @@
+import { Disposable } from '../../core/disposable';
+export interface ThrottleOptions {
+    /**
+     * If true, the first invocation of a throttled function will pass through.
+     */
+    readonly leading: boolean;
+    /**
+     * If true, when the throttle window time has elapsed, the function will be invoked.
+     * Either leading or trailing must be true.
+     * When trailing is true, timers will be used
+     */
+    readonly trailing: boolean;
+}
+export interface ThrottledCallback extends Disposable {
+    (): void;
+    /**
+     * Resets the throttle timer.
+     * If an inner call is pending, it will be immediately invoked.
+     */
+    reset(): void;
+}
+/**
+ * Throttle returns a function that limits the rate of invocations.
+ *
+ * @param inner The function to invoke at a throttled rate.
+ * @param duration The interval (in seconds) for which the throttled function will be limited.
+ * @param options Options for which ends of the window the function should be invoked. If omitted,
+ * leading and trailing will be true.
+ * @return Returns a method that, when invoked, will invoke the inner method at a throttled rate.
+ * The returned method will have a `dispose` handle to clear any active timers and prevent
+ * further invocation.
+ */
+export declare function throttle(inner: () => void, duration: number, options?: Partial<ThrottleOptions>): ThrottledCallback;
+//# sourceMappingURL=throttle.d.ts.map

package/dist/types/ts3.7/util/iteration/iterable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Returns an array of numbers between start and end, incrementing by step.
+ *
+ * E.g.
+ * ```
+ * range(1, 10) // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * range(5, 2) // [5, 4, 3, 2]
+ * range(5, 4, -0.2) // [5.0, 4.8, 4.6, 4.4, 4.2, 4.0]
+ * ```
+ * @param start Start position (inclusive)
+ * @param endInclusive End position (inclusive)
+ * @param step The amount to increment.
+ */
+export declare function createRangeIter(start: number, endInclusive: number, step?: number): IterableIterator<number>;
+/**
+ * Maps an iterable object using the given transform.
+ * Unlike `Array#map`, this doesn't create a new Array in memory, the transform is done on
+ * iteration.
+ *
+ * @param iterable
+ * @param transform Transforms each element as it's requested.
+ */
+export declare function mapIter<T, U>(iterable: Iterable<T>, transform: (element: T) => U): IterableIterator<U>;
+export declare function filterIter<T, S extends T>(iterable: Iterable<T>, predicate: (value: T) => value is S): IterableIterator<S>;
+export declare function filterIter<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): IterableIterator<T>;
+//# sourceMappingURL=iterable.d.ts.map

package/dist/types/ts3.7/util/map/map.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gets the value on map for the given key if it exists, otherwise sets [key] to `defaultValue`,
+ * returning the newly set value.
+ *
+ * @param map
+ * @param key
+ * @param defaultValue
+ */
+export declare function getOrSet<K, V>(map: Map<K, V>, key: K, defaultValue: (key: K) => V): V;
+/**
+ * Flips a map so that the keys become the values and the values become the keys.
+ *
+ * @param map
+ * @return Returns a new map.
+ */
+export declare function flipMap<K, V>(map: ReadonlyMap<K, V>): Map<V, K>;
+//# sourceMappingURL=map.d.ts.map

package/dist/types/ts3.7/util/math/math.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Clamps the given value between `min` and `max`.
+ *
+ * @param value
+ * @param min The lower bounds.
+ * @param max The upper bounds. If this value is less than min, this value will always be returned.
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Linearly interpolates between `from` and `to` given a percentage.
+ *
+ * @param from The alpha = 0.0 value
+ * @param to The alpha = 1.0 value
+ * @param alpha A percentage where 0 is `from`, and 1 is `to`. E.g. 0.5 would return halfway
+ * between `from` and `to`.
+ */
+export declare function lerp(from: number, to: number, alpha: number): number;
+/**
+ * Floors a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * floorToNearest(3, 2) // 2
+ * floorToNearest(16, 5) // 15
+ * floorToNearest(16, 5, 2) // 17
+ * ```
+ *
+ * @param value The value to floor with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export declare function floorToNearest(value: number, snap: number, offset?: number): number;
+/**
+ * Ceilings a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * ceilToNearest(3, 2) // 4
+ * ceilToNearest(16, 5) // 20
+ * ceilToNearest(10, 5) // 10
+ * ceilToNearest(16, 5, 2) // 22
+ * ```
+ *
+ * @param value The value to ceil with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export declare function ceilToNearest(value: number, snap: number, offset?: number): number;
+/**
+ * Rounds a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * roundToNearest(3, 2) // 4
+ * roundToNearest(16, 5) // 15
+ * roundToNearest(18, 5) // 20
+ * roundToNearest(16, 10, 2) // 22
+ * ```
+ *
+ * @param value The value to round with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export declare function roundToNearest(value: number, snap: number, offset?: number): number;
+/**
+ * Returns true if `x` is within `tolerance` of `y`.
+ *
+ * @param x
+ * @param y
+ * @param tolerance
+ */
+export declare function closeTo(x: number, y: number, tolerance?: number): boolean;
+//# sourceMappingURL=math.d.ts.map

package/dist/types/ts3.7/util/mpeg/parseSidxBox.d.ts

@@ -0,0 +1,100 @@
+/**
+ * ISO_IEC_14496-12 Segment Index Box
+ * @module
+ */
+/**
+ * Represents the base structure of a Segment Index ('sidx') Box.
+ * The 'sidx' box is used in MPEG-4 media files to provide indexing information for efficient data access and retrieval.
+ */
+export interface SidxBoxBase {
+    /**
+     * The version, 0 and 1 supported.
+     */
+    readonly version: number;
+    /**
+     * The ID of the track.
+     */
+    readonly referenceId: number;
+    /**
+     * The timescale for the media in this 'sidx' box. It is a 32-bit unsigned integer.
+     * This value represents the number of time units that pass in one second.
+     */
+    readonly timescale: number;
+    /**
+     * An array of segment references. Each segment reference provides information about individual media segments.
+     */
+    readonly references: readonly SidxSegmentReference[];
+}
+/**
+ * Properties specific to version 0 of a Segment Index ('sidx') Box.
+ */
+export interface SidxBoxV0 extends SidxBoxBase {
+    readonly version: 0;
+    /**
+     * The earliest presentation time of any access unit in the media segments that are referenced by this 'sidx' box.
+     */
+    readonly earliestPresentationTime: number;
+    /**
+     * The byte offset from the end of this 'sidx' box to the first media segment in this 'sidx'.
+     * For version 0, this is a 32-bit unsigned integer.
+     */
+    readonly firstOffset: number;
+}
+/**
+ * Properties specific to version 1 of a Segment Index ('sidx') Box.
+ */
+export interface SidxBoxV1 extends SidxBoxBase {
+    readonly version: 1;
+    /**
+     * The earliest presentation time of any access unit in the media segments that are referenced by this 'sidx' box.
+     */
+    readonly earliestPresentationTime: bigint;
+    /**
+     * The byte offset from the end of this 'sidx' box to the first media segment in this 'sidx'.
+     */
+    readonly firstOffset: bigint;
+}
+export type SidxBox = SidxBoxV0 | SidxBoxV1;
+/**
+ * A single segment reference within a sidx box.
+ */
+export interface SidxSegmentReference {
+    /**
+     * Indicates the reference type. A value of 0 means the reference is to a media segment. A value of 1 indicates
+     * the reference is to a hint track segment.
+     */
+    readonly referenceType: number;
+    /**
+     * The size of the referenced segment in bytes.
+     */
+    readonly referencedSize: number;
+    /**
+     * The duration of the subsegment. This is expressed in the timescale provided in the 'sidx' box.
+     */
+    readonly subsegmentDuration: number;
+    /**
+     * Indicates if the segment starts with a SAP (Stream Access Point). If `true`, the segment starts with a SAP,
+     * facilitating random access and efficient streaming.
+     */
+    readonly startsWithSap: boolean;
+    /**
+     * The SAP type indicates the type of stream access point that starts the segment. This is a 3-bit field. The
+     * SAP types are defined in ISO/IEC 14496-12, and they describe the characteristics of the stream access points.
+     */
+    readonly sapType: number;
+    /**
+     * The SAP delta time specifies the difference in time (in the timescale of the 'sidx' box) between the earliest
+     * presentation time of the segment and the first SAP within it. This allows players to quickly locate the SAP
+     * for efficient playback startup or seeking.
+     */
+    readonly sapDeltaTime: number;
+}
+export declare function parseSidxBox(buffer: ArrayBuffer): SidxBox;
+/**
+ * Creates a timeline of the segment start times, in timescale units.
+ * The last element will be the last segment's end time.
+ *
+ * @param sidx
+ */
+export declare function getSidxSampleTimes(sidx: SidxBox): number[];
+//# sourceMappingURL=parseSidxBox.d.ts.map

package/dist/types/ts3.7/util/network/request.d.ts

@@ -0,0 +1,18 @@
+import { Maybe } from '../../util/type';
+/**
+ * Given request parameters, returns the header for the given key, or null.
+ */
+export declare function getHeaderFromRequestParams(input: RequestInfo | URL, init: Maybe<RequestInit>, key: string): string | null;
+export declare function getHeaderFromHeadersInit(headers: Readonly<HeadersInit>, key: string): string | null;
+/**
+ * Given fetch input, clones the input, transforms the URL and returns a new `RequestInfo | URL` input parameter.
+ */
+export declare function changeRequestInputUrl(input: RequestInfo | URL, transform: (url: URL) => void): RequestInfo | URL;
+/**
+ * Given an object of HeadersInit type (a Headers instance, array of key-value pairs, or and object of key-value pairs),
+ * returns a Record of key-value pairs.
+ *
+ * @param headers
+ */
+export declare function normalizeHeadersInit(headers: Maybe<HeadersInit>): Record<string, string>;
+//# sourceMappingURL=request.d.ts.map

package/dist/types/ts3.7/util/object/clone.d.ts

@@ -0,0 +1,68 @@
+import { MergeRule } from './mergeDeep';
+import { MutableDeep } from './mutableType';
+/**
+ * Merge options defines the behavior for {@link mergeDeep}.
+ * See the {@link defaultMergeOptions} for defaults that will be used if any merge options are
+ * omitted.
+ */
+export interface CloneOptions {
+    /**
+     * If an object does not pass any of the rules, if this is true the reference will be
+     * copied. If false (default), a {@link MergeReferenceError} will be thrown.
+     * This only applies to objects, not functions or primitives.
+     */
+    readonly allowReferenceCopy: boolean;
+    /**
+     * The first clone rule that matches will be used.
+     *
+     * If no rules match, the value will be copied by reference unless `allowReferenceCopy` is
+     * false (default), in which case, a {@link MergeReferenceError} will be thrown.
+     */
+    readonly rules: readonly CloneRule<any>[];
+}
+/**
+ * A CloneRule defines if and how an object should be cloned.
+ */
+export interface CloneRule<T> {
+    /**
+     * Returns true if this MergeRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Clones the given value.
+     *
+     * @param source A value guaranteed to have matched with `matches`.
+     * @param clone This callback may be used to clone sub-properties.
+     */
+    readonly clone: (source: T, clone: CloneCallback) => MutableDeep<T>;
+}
+/**
+ * A function to clone a sub-object from a clone rule.
+ */
+export type CloneCallback = <T>(
+/**
+ * The source object to clone.
+ */
+source: T, 
+/**
+ * The identifier to be used in error reporting.
+ */
+prop: string | number) => MutableDeep<T>;
+/**
+ * Performs a deep clone on the target object.
+ *
+ * This is an alias for `mergeDeep(target)` that additionally converts clone rules to one-sided
+ * merge rules.
+ *
+ * @param target The target object to clone.
+ * @param options The merge options to use.
+ * `clone`, unlike `mergeDeep`, `allowReferenceCopy` will default to false.
+ * @see mergeDeep
+ */
+export declare function clone<T>(target: T, options?: Partial<CloneOptions>): MutableDeep<T>;
+/**
+ * Creates a wrapper to convert a clone rule to a merge rule.
+ */
+export declare function toMergeRule<T>(cloneRule: CloneRule<T>): MergeRule<T>;
+//# sourceMappingURL=clone.d.ts.map

package/dist/types/ts3.7/util/object/equalDeep.d.ts

@@ -0,0 +1,54 @@
+import { TypedArray } from '../../util/collection/typedArray';
+/**
+ * Recursively compares the values of all the enumerable own properties from two source objects.
+ *
+ * @param objectA
+ * @param objectB
+ * @param options
+ */
+export declare function equalDeep<T>(objectA: T, objectB: T, options?: EqualOptions): boolean;
+/**
+ * Configuration for the equalDeep comparator.
+ */
+export interface EqualOptions {
+    /**
+     * The first equal rule where the first source object matches will be used.
+     * If the second object does not match, the two objects will not be considered equal.
+     */
+    readonly rules: readonly EqualRule<any>[];
+}
+/**
+ * A equal function to be provided to equal rules.
+ */
+export type EqualCallback<T = any> = (objectA: T, objectB: T) => boolean;
+export interface EqualRule<T> {
+    /**
+     * Returns true if this EqualRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Equals the two sources.
+     * @param objectA May be undefined, the first object to equal.
+     * @param objectB The second object to equal or clone if objectA is undefined.
+     * @param equal This callback may be used to equal or clone sub-properties.
+     */
+    readonly equal: (objectA: T, objectB: T, equal: EqualCallback) => boolean;
+}
+export declare const arrayEqualRule: EqualRule<any[]>;
+export declare const plainObjectEqualRule: EqualRule<Record<any, any>>;
+export declare const regexpEqualRule: EqualRule<RegExp>;
+export declare const dateEqualRule: EqualRule<Date>;
+export declare const mapEqualRule: EqualRule<Map<any, any>>;
+export declare const setEqualRule: EqualRule<Set<any>>;
+/**
+ * A typed array will always have primitive elements, compare that the lengths are equal and every
+ * element is equal.
+ */
+export declare const typedArrayEqualRule: EqualRule<TypedArray>;
+/**
+ * The default equal options provide rules for comparing arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export declare const defaultEqualOptions: EqualOptions;
+//# sourceMappingURL=equalDeep.d.ts.map

package/dist/types/ts3.7/util/object/lazy.d.ts

@@ -0,0 +1,54 @@
+import { Disposable } from '../../core/disposable';
+export interface ReadonlyLazy<T> {
+    /**
+     * True if the lazy instance has been constructed.
+     */
+    readonly constructed: boolean;
+    /*
+    * When invoked the first time, constructs the value and returns it.
+    * Consecutive calls will return that cached value.
+    * @throws DisposedError If this lazy factory is disposed.
+    */
+    readonly value: T;
+}
+export interface Lazy<T> extends ReadonlyLazy<T>, Disposable {
+    /*
+    * Sets the lazy instance's value.
+    * If disposed, a {@link DisposedError} will be thrown.
+    * @param value
+    */
+    value: T;
+    /**
+     * Clears the lazy instance, disposing its value.
+     * Unlike dispose(), this allows the lazy instance to be reconstructed upon the next get.
+     * Typically used only in unit testing. May be used after {@link dispose}.
+     */
+    clear(): void;
+}
+/**
+ * A factory to lazily instantiate a single cached instance.
+ */
+export declare class LazyImpl<T> implements Lazy<T>, Disposable {
+    private readonly factory;
+    private _constructing;
+    private _constructed;
+    private disposed;
+    private _value;
+    /**
+     * @param factory A factory function that will be invoked at most once.
+     */
+    constructor(factory: () => T);
+    get constructed(): boolean;
+    get value(): T;
+    set value(value: T);
+    clear(): void;
+    dispose(): void;
+}
+/**
+ * Creates a new {@link Lazy} instance.
+ *
+ * @param factory A factory function that will be invoked at most once. If the instance produced
+ * is disposable, it will be disposed on clear.
+ */
+export declare function lazy<T>(factory: () => T): Lazy<T>;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/types/ts3.7/util/object/merge.d.ts

@@ -0,0 +1,72 @@
+/**
+ * An intersection of T & U where common keys of T and U are overwritten by U.
+ */
+export type Merge<T, U> = Omit<T, keyof U> & U;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T>(source1: T): T;
+/**
+ * Concatenates arrays.
+ *
+ * @return Returns a new concatenated array.
+ */
+export declare function merge<T>(...sources: T[][]): T[];
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U>(source1: T, source2: U): Merge<T, U>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @param source3 The third source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U, V>(source1: T, source2: U, source3: V): Merge<Merge<T, U>, V>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @param source3 The third source object from which to copy properties.
+ * @param source4 The third source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U, V, W>(source1: T, source2: U, source3: V, source4: W): Merge<Merge<Merge<T, U>, V>, W>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param sources
+ * @return Returns the new merged object.
+ */
+export declare function merge(...sources: any[]): any;
+//# sourceMappingURL=merge.d.ts.map