pinets 0.2.1 → 0.5.0

package/dist/types/Series.d.ts

@@ -0,0 +1,10 @@
+export declare class Series {
+    data: any[];
+    offset: number;
+    constructor(data: any[], offset?: number);
+    get(index: number): any;
+    set(index: number, value: any): void;
+    get length(): number;
+    toArray(): any[];
+    static from(source: any): Series;
+}

package/dist/types/TimeSeries.class.d.ts

@@ -0,0 +1,49 @@
+import Context from '../Context.class';
+/**
+ * A lightweight wrapper around arrays to provide Pine Script-like "series" access behavior.
+ * Pine Script series are indexed relative to the current bar:
+ * - series[0] is the current value
+ * - series[1] is the previous value
+ *
+ * This class maps this reversed, relative indexing to the underlying chronological array
+ * using the Context's current index.
+ */
+export declare class TimeSeries<T = any> {
+    private readonly _data;
+    private readonly _ctx;
+    constructor(_data: T[], _ctx: Context);
+    /**
+     * Get the value at the specified offset from the current bar.
+     * @param offset The lookback offset (0 = current, 1 = previous, etc.)
+     */
+    get(offset: number): T;
+    /**
+     * Set the value at the specified offset from the current bar.
+     * Usually used for setting current value (offset 0).
+     */
+    set(offset: number, value: T): T;
+    /**
+     * Get the length of the series *so far* (up to current index)
+     * Note: This mimics the behavior where future data isn't "visible" yet
+     */
+    get length(): number;
+    /**
+     * Returns the underlying raw data array.
+     * Useful for performance-critical bulk operations that understand the indexing.
+     */
+    get data(): T[];
+    /**
+     * Creates a copy of the visible series as a reversed array (Pine Script standard format for bulk ops).
+     * Warning: This is O(N) and should be used sparingly.
+     */
+    toArray(): T[];
+    /**
+     * Push a value to the underlying array.
+     * Used when constructing user-defined series dynamically.
+     */
+    push(value: T): number;
+    /**
+     * Update the underlying array reference (e.g. for re-assignment)
+     */
+    replaceData(newData: T[]): void;
+}

package/dist/types/TimeSeries.d.ts

@@ -0,0 +1,15 @@
+export interface IContext {
+    idx: number;
+    NA: any;
+}
+export declare class TimeSeries<T = any> {
+    private _data;
+    private context;
+    constructor(context: IContext, data?: T[]);
+    get(offset: number): T;
+    set(value: T, offset?: number): void;
+    push(value: T): void;
+    pop(): T | undefined;
+    get data(): T[];
+    get length(): number;
+}

package/dist/types/marketData/Mock/MockProvider.class.d.ts

@@ -0,0 +1,77 @@
+import { IProvider } from '@pinets/marketData/IProvider';
+interface Kline {
+    openTime: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    closeTime: number;
+    quoteAssetVolume: number;
+    numberOfTrades: number;
+    takerBuyBaseAssetVolume: number;
+    takerBuyQuoteAssetVolume: number;
+    ignore: number | string;
+}
+/**
+ * Mock Market Data Provider for Unit Tests
+ *
+ * This provider reads market data from pre-fetched JSON files instead of making API calls.
+ * It's designed to be used in unit tests to provide consistent, offline test data.
+ *
+ * Usage:
+ * ```typescript
+ * const mockProvider = new MockProvider();
+ * const data = await mockProvider.getMarketData('BTCUSDC', '1h', 100, startTime, endTime);
+ * ```
+ *
+ * The provider looks for JSON files in the tests/compatibility/_data directory
+ * with the naming pattern: {SYMBOL}-{TIMEFRAME}-{START_TIME}-{END_TIME}.json
+ *
+ * Example: BTCUSDC-1h-1704067200000-1763683199000.json
+ */
+export declare class MockProvider implements IProvider {
+    private dataCache;
+    private readonly dataDirectory;
+    constructor(dataDirectory?: string);
+    /**
+     * Generates a cache key for the data file
+     */
+    private getDataFileName;
+    /**
+     * Loads data from JSON file
+     */
+    private loadDataFromFile;
+    /**
+     * Finds the best matching data file for the given parameters
+     */
+    private findDataFile;
+    /**
+     * Filters data based on date range and limit
+     */
+    private filterData;
+    /**
+     * Normalizes timeframe to match file naming convention
+     */
+    private normalizeTimeframe;
+    /**
+     * Implements IProvider.getMarketData
+     *
+     * @param tickerId - Symbol (e.g., 'BTCUSDC')
+     * @param timeframe - Timeframe (e.g., '1h', '60', 'D')
+     * @param limit - Optional limit on number of candles to return
+     * @param sDate - Optional start date (timestamp in milliseconds)
+     * @param eDate - Optional end date (timestamp in milliseconds)
+     * @returns Promise<Kline[]> - Array of candle data
+     */
+    getMarketData(tickerId: string, timeframe: string, limit?: number, sDate?: number, eDate?: number): Promise<Kline[]>;
+    /**
+     * Clears the data cache
+     */
+    clearCache(): void;
+    /**
+     * Sets a custom data directory
+     */
+    setDataDirectory(directory: string): void;
+}
+export {};

package/dist/types/marketData/Provider.class.d.ts

@@ -1,4 +1,7 @@
-import { BinanceProvider } from './Binance/BinanceProvider.class';
-export declare const Provider: {
-    Binance: BinanceProvider;
+import { IProvider } from './IProvider';
+type TProvider = {
+    [key: string]: IProvider;
 };
+export declare const Provider: TProvider;
+export declare function registerProvider(name: string, provider: IProvider): void;
+export {};

package/dist/types/namespaces/Core.d.ts

@@ -18,6 +18,7 @@ export declare class Core {
     indicator(title: string, shorttitle?: string, options?: IndicatorOptions): void;
     plotchar(series: number[], title: string, options: PlotCharOptions): void;
     plot(series: any, title: string, options: PlotOptions): void;
+    get bar_index(): any;
     na(series: any): boolean;
     nz(series: any, replacement?: number): any;
 }

package/dist/types/namespaces/array/PineArrayObject.d.ts

@@ -0,0 +1,5 @@
+export declare class PineArrayObject {
+    array: any;
+    constructor(array: any);
+    toString(): string;
+}

package/dist/types/namespaces/array/array.index.d.ts

@@ -0,0 +1,135 @@
+export { PineArrayObject } from './PineArrayObject';
+import { abs } from './methods/abs';
+import { avg } from './methods/avg';
+import { clear } from './methods/clear';
+import { concat } from './methods/concat';
+import { copy } from './methods/copy';
+import { covariance } from './methods/covariance';
+import { every } from './methods/every';
+import { fill } from './methods/fill';
+import { first } from './methods/first';
+import { from } from './methods/from';
+import { get } from './methods/get';
+import { includes } from './methods/includes';
+import { indexof } from './methods/indexof';
+import { insert } from './methods/insert';
+import { join } from './methods/join';
+import { last } from './methods/last';
+import { lastindexof } from './methods/lastindexof';
+import { max } from './methods/max';
+import { min } from './methods/min';
+import { new_fn } from './methods/new';
+import { new_bool } from './methods/new_bool';
+import { new_float } from './methods/new_float';
+import { new_int } from './methods/new_int';
+import { new_string } from './methods/new_string';
+import { param } from './methods/param';
+import { pop } from './methods/pop';
+import { push } from './methods/push';
+import { range } from './methods/range';
+import { remove } from './methods/remove';
+import { reverse } from './methods/reverse';
+import { set } from './methods/set';
+import { shift } from './methods/shift';
+import { size } from './methods/size';
+import { slice } from './methods/slice';
+import { some } from './methods/some';
+import { sort } from './methods/sort';
+import { sort_indices } from './methods/sort_indices';
+import { standardize } from './methods/standardize';
+import { stdev } from './methods/stdev';
+import { sum } from './methods/sum';
+import { unshift } from './methods/unshift';
+import { variance } from './methods/variance';
+declare const methods: {
+    abs: typeof abs;
+    avg: typeof avg;
+    clear: typeof clear;
+    concat: typeof concat;
+    copy: typeof copy;
+    covariance: typeof covariance;
+    every: typeof every;
+    fill: typeof fill;
+    first: typeof first;
+    from: typeof from;
+    get: typeof get;
+    includes: typeof includes;
+    indexof: typeof indexof;
+    insert: typeof insert;
+    join: typeof join;
+    last: typeof last;
+    lastindexof: typeof lastindexof;
+    max: typeof max;
+    min: typeof min;
+    new: typeof new_fn;
+    new_bool: typeof new_bool;
+    new_float: typeof new_float;
+    new_int: typeof new_int;
+    new_string: typeof new_string;
+    param: typeof param;
+    pop: typeof pop;
+    push: typeof push;
+    range: typeof range;
+    remove: typeof remove;
+    reverse: typeof reverse;
+    set: typeof set;
+    shift: typeof shift;
+    size: typeof size;
+    slice: typeof slice;
+    some: typeof some;
+    sort: typeof sort;
+    sort_indices: typeof sort_indices;
+    standardize: typeof standardize;
+    stdev: typeof stdev;
+    sum: typeof sum;
+    unshift: typeof unshift;
+    variance: typeof variance;
+};
+export declare class PineArray {
+    private context;
+    private _cache;
+    abs: ReturnType<typeof methods.abs>;
+    avg: ReturnType<typeof methods.avg>;
+    clear: ReturnType<typeof methods.clear>;
+    concat: ReturnType<typeof methods.concat>;
+    copy: ReturnType<typeof methods.copy>;
+    covariance: ReturnType<typeof methods.covariance>;
+    every: ReturnType<typeof methods.every>;
+    fill: ReturnType<typeof methods.fill>;
+    first: ReturnType<typeof methods.first>;
+    from: ReturnType<typeof methods.from>;
+    get: ReturnType<typeof methods.get>;
+    includes: ReturnType<typeof methods.includes>;
+    indexof: ReturnType<typeof methods.indexof>;
+    insert: ReturnType<typeof methods.insert>;
+    join: ReturnType<typeof methods.join>;
+    last: ReturnType<typeof methods.last>;
+    lastindexof: ReturnType<typeof methods.lastindexof>;
+    max: ReturnType<typeof methods.max>;
+    min: ReturnType<typeof methods.min>;
+    new: ReturnType<typeof methods.new>;
+    new_bool: ReturnType<typeof methods.new_bool>;
+    new_float: ReturnType<typeof methods.new_float>;
+    new_int: ReturnType<typeof methods.new_int>;
+    new_string: ReturnType<typeof methods.new_string>;
+    param: ReturnType<typeof methods.param>;
+    pop: ReturnType<typeof methods.pop>;
+    push: ReturnType<typeof methods.push>;
+    range: ReturnType<typeof methods.range>;
+    remove: ReturnType<typeof methods.remove>;
+    reverse: ReturnType<typeof methods.reverse>;
+    set: ReturnType<typeof methods.set>;
+    shift: ReturnType<typeof methods.shift>;
+    size: ReturnType<typeof methods.size>;
+    slice: ReturnType<typeof methods.slice>;
+    some: ReturnType<typeof methods.some>;
+    sort: ReturnType<typeof methods.sort>;
+    sort_indices: ReturnType<typeof methods.sort_indices>;
+    standardize: ReturnType<typeof methods.standardize>;
+    stdev: ReturnType<typeof methods.stdev>;
+    sum: ReturnType<typeof methods.sum>;
+    unshift: ReturnType<typeof methods.unshift>;
+    variance: ReturnType<typeof methods.variance>;
+    constructor(context: any);
+}
+export default PineArray;

package/dist/types/namespaces/array/methods/abs.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function abs(context: any): (id: PineArrayObject) => PineArrayObject;

package/dist/types/namespaces/array/methods/avg.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function avg(context: any): (id: PineArrayObject) => number;

package/dist/types/namespaces/array/methods/clear.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function clear(context: any): (id: PineArrayObject) => void;

package/dist/types/namespaces/array/methods/concat.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function concat(context: any): (id: PineArrayObject, other: PineArrayObject) => PineArrayObject;

package/dist/types/namespaces/array/methods/copy.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function copy(context: any): (id: PineArrayObject) => PineArrayObject;

package/dist/types/namespaces/array/methods/covariance.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function covariance(context: any): (arr1: PineArrayObject, arr2: PineArrayObject, biased?: boolean) => number;

package/dist/types/namespaces/array/methods/every.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function every(context: any): (id: PineArrayObject, callback: (val: any) => boolean) => boolean;

package/dist/types/namespaces/array/methods/fill.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function fill(context: any): (id: PineArrayObject, value: any, start?: number, end?: number) => void;

package/dist/types/namespaces/array/methods/first.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function first(context: any): (id: PineArrayObject) => any;

package/dist/types/namespaces/array/methods/from.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function from(context: any): (...values: any[]) => PineArrayObject;

package/dist/types/namespaces/array/methods/get.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function get(context: any): (id: PineArrayObject, index: number) => any;

package/dist/types/namespaces/array/methods/includes.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function includes(context: any): (id: PineArrayObject, value: any) => boolean;

package/dist/types/namespaces/array/methods/indexof.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function indexof(context: any): (id: PineArrayObject, value: any) => number;

package/dist/types/namespaces/array/methods/insert.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function insert(context: any): (id: PineArrayObject, index: number, value: any) => void;

package/dist/types/namespaces/array/methods/join.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function join(context: any): (id: PineArrayObject, separator?: string) => string;

package/dist/types/namespaces/array/methods/last.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function last(context: any): (id: PineArrayObject) => any;

package/dist/types/namespaces/array/methods/lastindexof.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function lastindexof(context: any): (id: PineArrayObject, value: any) => number;

package/dist/types/namespaces/array/methods/max.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function max(context: any): (id: PineArrayObject, nth?: number) => number;

package/dist/types/namespaces/array/methods/min.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function min(context: any): (id: PineArrayObject, nth?: number) => number;

package/dist/types/namespaces/array/methods/new.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function new_fn(context: any): <T>(size: number, initial_value: T) => PineArrayObject;

package/dist/types/namespaces/array/methods/new_bool.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function new_bool(context: any): (size: number, initial_value?: boolean) => PineArrayObject;

package/dist/types/namespaces/array/methods/new_float.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function new_float(context: any): (size: number, initial_value?: number) => PineArrayObject;

package/dist/types/namespaces/array/methods/new_int.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function new_int(context: any): (size: number, initial_value?: number) => PineArrayObject;

package/dist/types/namespaces/array/methods/new_string.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function new_string(context: any): (size: number, initial_value?: string) => PineArrayObject;

package/dist/types/namespaces/array/methods/param.d.ts

@@ -0,0 +1 @@
+export declare function param(context: any): (source: any, index?: number) => any;

package/dist/types/namespaces/array/methods/pop.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function pop(context: any): (id: PineArrayObject) => any;

package/dist/types/namespaces/array/methods/push.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function push(context: any): (id: PineArrayObject, value: any) => void;

package/dist/types/namespaces/array/methods/range.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function range(context: any): (id: PineArrayObject) => number;

package/dist/types/namespaces/array/methods/remove.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function remove(context: any): (id: PineArrayObject, index: number) => any;

package/dist/types/namespaces/array/methods/reverse.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function reverse(context: any): (id: PineArrayObject) => void;

package/dist/types/namespaces/array/methods/set.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function set(context: any): (id: PineArrayObject, index: number, value: any) => void;

package/dist/types/namespaces/array/methods/shift.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function shift(context: any): (id: PineArrayObject) => any;

package/dist/types/namespaces/array/methods/size.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function size(context: any): (id: PineArrayObject) => number;

package/dist/types/namespaces/array/methods/slice.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function slice(context: any): (id: PineArrayObject, start: number, end?: number) => PineArrayObject;

package/dist/types/namespaces/array/methods/some.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function some(context: any): (id: PineArrayObject, callback: (val: any) => boolean) => boolean;

package/dist/types/namespaces/array/methods/sort.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function sort(context: any): (id: PineArrayObject, order?: "asc" | "desc") => void;

package/dist/types/namespaces/array/methods/sort_indices.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function sort_indices(context: any): (id: PineArrayObject, comparator?: (a: any, b: any) => number) => PineArrayObject;

package/dist/types/namespaces/array/methods/standardize.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function standardize(context: any): (id: PineArrayObject) => PineArrayObject;

package/dist/types/namespaces/array/methods/stdev.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function stdev(context: any): (id: PineArrayObject, biased?: boolean) => number;

package/dist/types/namespaces/array/methods/sum.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function sum(context: any): (id: PineArrayObject) => number;

package/dist/types/namespaces/array/methods/unshift.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function unshift(context: any): (id: PineArrayObject, value: any) => void;

package/dist/types/namespaces/array/methods/variance.d.ts

@@ -0,0 +1,2 @@
+import { PineArrayObject } from '../PineArrayObject';
+export declare function variance(context: any): (id: PineArrayObject, biased?: boolean) => number;

package/dist/types/namespaces/input/input.index.d.ts

@@ -0,0 +1,53 @@
+export type { InputOptions } from './types';
+import { any } from './methods/any';
+import { bool } from './methods/bool';
+import { color } from './methods/color';
+import { enum_fn } from './methods/enum';
+import { float } from './methods/float';
+import { int } from './methods/int';
+import { param } from './methods/param';
+import { price } from './methods/price';
+import { session } from './methods/session';
+import { source } from './methods/source';
+import { string } from './methods/string';
+import { symbol } from './methods/symbol';
+import { text_area } from './methods/text_area';
+import { time } from './methods/time';
+import { timeframe } from './methods/timeframe';
+declare const methods: {
+    any: typeof any;
+    bool: typeof bool;
+    color: typeof color;
+    enum: typeof enum_fn;
+    float: typeof float;
+    int: typeof int;
+    param: typeof param;
+    price: typeof price;
+    session: typeof session;
+    source: typeof source;
+    string: typeof string;
+    symbol: typeof symbol;
+    text_area: typeof text_area;
+    time: typeof time;
+    timeframe: typeof timeframe;
+};
+export declare class Input {
+    private context;
+    any: ReturnType<typeof methods.any>;
+    bool: ReturnType<typeof methods.bool>;
+    color: ReturnType<typeof methods.color>;
+    enum: ReturnType<typeof methods.enum>;
+    float: ReturnType<typeof methods.float>;
+    int: ReturnType<typeof methods.int>;
+    param: ReturnType<typeof methods.param>;
+    price: ReturnType<typeof methods.price>;
+    session: ReturnType<typeof methods.session>;
+    source: ReturnType<typeof methods.source>;
+    string: ReturnType<typeof methods.string>;
+    symbol: ReturnType<typeof methods.symbol>;
+    text_area: ReturnType<typeof methods.text_area>;
+    time: ReturnType<typeof methods.time>;
+    timeframe: ReturnType<typeof methods.timeframe>;
+    constructor(context: any);
+}
+export default Input;

package/dist/types/namespaces/input/methods/any.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function any(context: any): (value: any, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/bool.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function bool(context: any): (value: boolean, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/color.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function color(context: any): (value: string, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/enum.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function enum_fn(context: any): (value: string, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/float.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function float(context: any): (value: number, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/int.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function int(context: any): (value: number, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/param.d.ts

@@ -0,0 +1 @@
+export declare function param(context: any): (source: any, index?: number) => any[];

package/dist/types/namespaces/input/methods/price.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function price(context: any): (value: number, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/session.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function session(context: any): (value: string, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/source.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function source(context: any): (value: any, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/string.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function string(context: any): (value: string, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/symbol.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function symbol(context: any): (value: string, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/text_area.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function text_area(context: any): (value: string, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/time.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function time(context: any): (value: number, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/methods/timeframe.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from '../types';
+export declare function timeframe(context: any): (value: string, { title, group }?: InputOptions) => any;

package/dist/types/namespaces/input/types.d.ts

@@ -0,0 +1,4 @@
+export type InputOptions = {
+    title?: string;
+    group?: string;
+} | any;