/**
 * Chunk a matrix array into columns.
 *
 * [              [
 *   1, 2, 3,       [1, 4, 7],
 *   4, 5, 6,  ->   [2, 5, 8],
 *   7, 8, 9,       [3, 6, 9],
 * ]              ]
 */
export declare function cols<T>(matrix: T[]): T[][];
/**
 * Find the coordinates of an index inside a square matrix.
 */
export declare function coords(index: number, size: number): {
    col: number;
    mid: number;
    odd: boolean;
    row: number;
};
/**
 * Extract a layer of values.
 *
 * @param {T[]} target Matrix to extract values from.
 * @param {number} angle Angle to extract values from.
 * @param {number} depth Depth to extract values from.
 */
export declare function extract<T>(target: T[], angle: number, depth: number): T[];
/**
 * Flatten an array of columns.
 *
 * [                [
 *   [1, 4, 7],       1, 2, 3,
 *   [2, 5, 8],  ->   4, 5, 6,
 *   [3, 6, 9],       7, 8, 9,
 * ]                ]
 *
 * @param {T[][]} arr Array of column values.
 *
 * @return {T[]}
 */
export declare function flattenCols<T>(arr: T[][]): T[];
/**
 * Flatten an array of rows.
 *
 * [                [
 *   [1, 2, 3],       1, 2, 3,
 *   [4, 5, 6],  ->   4, 5, 6,
 *   [7, 8, 9],       7, 8, 9,
 * ]                ]
 *
 * @param {T[][]} arr Array of row values.
 *
 * @return {T[]}
 */
export declare function flattenRows<T>(arr: T[][]): T[];
/**
 * Convert between row and column arrays. A good way to
 * visualize this operation is holding a card by the top-left
 * and bottom-right corners and flipping it over.
 *
 * [                [
 *   [1, 2, 3],       [1, 4, 7],
 *   [4, 5, 6],  ->   [2, 5, 8],
 *   [7, 8, 9],       [3, 6, 9],
 * ]                ]
 *
 * @param {T[][]} arrs
 *
 * @return {T[][]}
 */
export declare function flip<T>(arrs: T[][]): T[][];
/**
 * Inject values into a matrix.
 *
 * @param {T[]} arr Values to inject.
 * @param {T[]} target Matrix to inject values into.
 * @param {number} angle Angle to inject values from.
 * @param {number} depth Depth to inject values at.
 *
 * @return {T[]}
 */
export declare function inject<T>(arr: T[], target: T[], angle: number, depth: number): T[];
/**
 * Rotate a matrix array.
 *
 * @param {T[]} matrix Source matrix to rotate.
 * @param {number} angle Integer number of rotations. Positive numbers rotate clockwise, negative rotates counter-clockwise.
 *
 * @return {T[]}
 */
export declare function rotate<T>(matrix: T[], angle: number): T[];
/**
 * Chunk a matrix array into rows.
 *
 * [              [
 *   1, 2, 3,       [1, 2, 3],
 *   4, 5, 6,  ->   [4, 5, 6],
 *   7, 8, 9,       [7, 8, 9],
 * ]              ]
 *
 * @param {T[]} arr
 *
 * @return {T[][]}
 */
export declare function rows<T>(arr: T[]): T[][];