import { NodeDefinition, NodeLike, StatelessGraphNode, StatelessNodeDefinition, StatelessNodeType } from '../../../types/graph';
/**
 * An instance of the [[groupBy]] node.
 * See the [[groupBy]] documentation to find out more.
 */
export interface GroupByNode extends StatelessGraphNode<'group-by', GroupByNodeProperties> {
}
/**
 * A definition of the [[groupBy]] node.
 * See the [[groupBy]] documentation to find out more.
 */
export interface GroupByNodeDefinition extends StatelessNodeDefinition<'group-by', GroupByNodeProperties> {
}
export interface GroupByNodeProperties {
    predicate: NodeDefinition;
}
/**
 * The implementation of the [[groupBy]].
 * See the [[groupBy]] documentation to learn more.
 */
export declare const GroupByNodeType: StatelessNodeType<'group-by', GroupByNodeProperties>;
/**
 * Creates a new instance of a [[groupBy]] transform, which is a type of collection transform used to group
 * the items by a given predicate.
 * The [[groupBy]] node takes a predicate node that needs to implement a `call` operation (e.g. [[fn]], [[action]]).
 * The [[groupBy]] transform returns an array of grouped items. Consider a following example:
 * ```js
 * muster({
 *    items: [
 *      { category: 'vegetable', name: 'carrot' },
 *      { category: 'fruit', name: 'apple' },
 *      { category: 'fruit', name: 'plum' },
 *      { category: 'vegetable', name: 'potato' },
 *      { category: 'confectionery', name: 'chocolate' },
 *    ],
 *    groupedItems: applyTransforms(
 *      ref('items'),
 *      [groupBy((item) => get(item, 'category'))],
 *    ),
 *  })
 * ```
 * The `groupedItems` collection has following items:
 * ```js
 * array([
 *   array([
 *     { category: 'vegetable', name: 'carrot' },
 *     { category: 'vegetable', name: 'potato' },
 *   ]),
 *   array([
 *     { category: 'fruit', name: 'apple' },
 *     { category: 'fruit', name: 'plum' },
 *   ]),
 *   array([{ category: 'confectionery', name: 'chocolate' }])
 * ])
 * ```
 */
export declare function groupBy(predicate: NodeDefinition | NodeLike | ((item: NodeDefinition) => NodeDefinition | NodeLike)): GroupByNodeDefinition;