@tannerntannern/budgeteer/dist/resources.d.ts

A specialized constraint solver for budget flows

import { TwoKeyMap } from './two-key-map';
declare type Supply = 'supply';
declare type Consumer = 'consumer';
declare type Pipe = 'pipe';
declare type Supplyable = Consumer | Pipe;
declare type Consumable = Supply | Pipe;
declare type NodeType = Supply | Consumer | Pipe;
declare type To<T extends NodeType = Consumable> = {
    to: (node: FlowNode<Supplyable>) => FlowNode<T>;
};
declare type From<T extends NodeType = Supplyable> = {
    from: (node: FlowNode<Consumable>) => FlowNode<T>;
};
declare type NodeBase = {
    name: string;
    type: NodeType;
};
declare type FlowNode<T extends NodeType = NodeType> = NodeBase & (T extends Consumable ? {
    supplies: (amount: number, multiplier?: number) => To<T>;
    suppliesAsMuchAsNecessary: () => To<T>;
    suppliesAsMuchAsPossible: () => To<T>;
} : {}) & (T extends Supplyable ? {
    consumes: (amount: number, multiplier?: number) => From<T>;
    consumesAsMuchAsNecessary: () => From<T>;
    consumesAsMuchAsPossible: () => From<T>;
} : {});
/**
 * Clears all nodes, relationships, and constraints, and resets the kiwi.js solver.
 */
declare const reset: () => void;
/**
 * Creates a supply node.
 */
declare function supply(name: string, capacity: number, multiplier?: number): FlowNode<Supply>;
/**
 * Creates a consumer node.
 */
declare function consumer(name: string): FlowNode<Consumer>;
/**
 * Creates a pipe node.
 */
declare function pipe(name: string): FlowNode<Pipe>;
/**
 * Resolves the balances and tranfers of the network.
 */
declare function solve(): {
    allNodes: FlowNode<NodeType>[];
    transfers: TwoKeyMap<FlowNode<NodeType>, number>;
    balances: Map<FlowNode<NodeType>, number>;
};
export { supply, consumer, pipe, solve, reset };