ghostos 0.1.0 → 0.1.2

package/lib/api/parser/leaflisp/plispstdlib/index.d.ts

@@ -0,0 +1,396 @@
+export var Ordering: any;
+export class PLBool {
+    static fromJS(value: any): PLBool;
+    static fromStr(str: any): PLBool;
+    constructor(_value: any);
+    _value: any;
+    get value(): any;
+    not(): PLBool;
+    and(other: any): PLBool;
+    or(other: any): PLBool;
+    equals(other: any): PLBool;
+    partialCmp(other: any): any;
+    copy(): PLBool;
+    toString(): "true" | "false";
+    toJS(): any;
+    toJSON(): any;
+    debugTypeOf(): PLString;
+}
+export namespace PLBool {
+    let kind: string;
+}
+export class NothingClass {
+    static fromStr(str: any): NothingClass;
+    _value: any;
+    get value(): null;
+    equals(other: any): PLBool;
+    not(): PLBool;
+    toJS(): null;
+    toJSON(): null;
+    toString(): string;
+    debugTypeOf(): PLString;
+}
+export namespace NothingClass {
+    let kind_1: string;
+    export { kind_1 as kind };
+}
+export class PLFractionNumber {
+    constructor(numerator: any, denominator: any);
+    _n: number;
+    _d: number;
+    get numerator(): number;
+    get denominator(): number;
+    equals(a: any): PLBool;
+    negate(): PLFractionNumber;
+    add(a: any): PLFractionNumber;
+    subtract(a: any): PLFractionNumber;
+    multiply(a: any): PLFractionNumber;
+    divide(a: any): PLFractionNumber;
+    partialCmp(other: any): any;
+    toJS(): {
+        numerator: number;
+        denominator: number;
+    };
+    toJSON(): string;
+    toString(): string;
+    copy(): PLFractionNumber;
+    debugTypeOf(): PLString;
+}
+export namespace PLFractionNumber {
+    let kind_2: string;
+    export { kind_2 as kind };
+}
+export class PLHashMap {
+    constructor(list?: any[]);
+    _value: Map<any, any>;
+    get value(): Map<any, any>;
+    toJS(): Map<any, any>;
+    toJSON(): {};
+    toString(): string;
+    debugTypeOf(): PLString;
+    index(idx: any): any;
+}
+export namespace PLHashMap {
+    let kind_3: string;
+    export { kind_3 as kind };
+}
+export class PLNumber {
+    constructor(intValue: any, decimals?: number);
+    _decimals: any;
+    _intValue: any;
+    get intValue(): any;
+    get decimals(): any;
+    get value(): number;
+    equals(d: any): PLBool;
+    negate(): PLNumber;
+    add(d: any): PLNumber;
+    subtract(d: any): PLNumber;
+    multiply(d: any): PLNumber;
+    divide(d: any): PLNumber;
+    partialCmp(other: any): any;
+    toJS(): number;
+    toString(): string;
+    copy(): PLNumber;
+    debugTypeOf(): PLString;
+    isInteger(): PLBool;
+    toJSON(): string;
+}
+export namespace PLNumber {
+    let kind_4: string;
+    export { kind_4 as kind };
+}
+export class PLString {
+    static fromJS(value: any): PLString;
+    static fromStr(value: any): any;
+    constructor(_value: any);
+    _value: any;
+    get value(): any;
+    add(other: any): PLString;
+    index(idx: any): PLString;
+    slice(start: any, end: any): PLString;
+    equals(other: any): PLBool;
+    partialCmp(other: any): any;
+    copy(): PLString;
+    toJS(): any;
+    toJSON(): any;
+    toString(): string;
+    debugTypeOf(): PLString;
+    contains(item: any): PLBool;
+    count(): PLNumber;
+}
+export namespace PLString {
+    let kind_5: string;
+    export { kind_5 as kind };
+}
+export class PLVector {
+    constructor(value: any);
+    _value: any;
+    get value(): any;
+    contains(item: any): PLBool;
+    add(a: any): PLVector;
+    count(): PLNumber;
+    map(fn: any): PLVector;
+    filter(fn: any): PLVector;
+    reverse(): PLVector;
+    reduce(init: any, fn: any): any;
+    intersperse(elem: any): PLVector;
+    toJS(): any;
+    toJSON(): any;
+    toString(): string;
+    index(idx: any): any;
+    slice(start: any, end: any): PLVector;
+    copy(): PLVector;
+    deepCopy(): PLVector;
+    debugTypeOf(): PLString;
+}
+export namespace PLVector {
+    let kind_6: string;
+    export { kind_6 as kind };
+}
+export class StdRuntimeError extends Error {
+    constructor(error: any);
+    stack: any;
+}
+export function add(a: any, b: any): any;
+export function and(a: any, b: any): any;
+export function assert(val: any, msg: any): boolean;
+export function assertNumeric(strValue: any): boolean;
+export function contains(item: any, collection: any): any;
+export function copy(item: any): any;
+export function count(collection: any): any;
+export function debugTypeOf(v: any): any;
+export function deepCopy(item: any): any;
+export function divide(a: any, b: any): any;
+export function equals(a: any, b: any): any;
+export function filter(fn: any, f: any): any;
+export function get(data: any, idx: any): any;
+export function greaterOrEqual(a: any, b: any): PLBool;
+export function greaterThen(a: any, b: any): any;
+export function identity(x: any): any;
+export function isScientific(strValue: any): boolean;
+export function lessOrEqual(a: any, b: any): PLBool;
+export function lessThen(a: any, b: any): any;
+export namespace literals {
+    namespace Bool {
+        export { parseBool as parser };
+        export { plBoolConstructor as factory };
+    }
+    namespace Nothing {
+        export { parseNothing as parser };
+        export { plNothingConstructor as factory };
+    }
+    namespace Int {
+        export { plNumber as parser };
+        export { plIntegerConstructor as factory };
+    }
+    namespace Float {
+        export { plNumber as parser };
+        export { plFloatConstructor as factory };
+    }
+    namespace FractionNumber {
+        export { str2plFractionNumber as parser };
+        export { plFractionNumberConstructor as factory };
+    }
+    namespace String {
+        export { plString as parser };
+        export { plStringConstructor as factory };
+    }
+    namespace Vector {
+        export { identity as parser };
+        export { plVector as factory };
+    }
+    namespace HashMap {
+        export { identity as parser };
+        export { plHashMap as factory };
+    }
+}
+export function map(fn: any, f: any): any;
+export function multiply(a: any, b: any): any;
+export function negate(a: any): any;
+export function not(a: any): any;
+export function notEquals(a: any, b: any): any;
+export function or(a: any, b: any): any;
+export function parseDecimalString(strValue: any): {
+    intValue: number;
+    decimals: any;
+};
+export function parseScientificString(strValue: any): {
+    intValue: number;
+    decimals: any;
+};
+export function plBool(value: any): PLBool;
+export function plFractionNumber(n: any, d: any): PLFractionNumber;
+export function plHashMap(...list: any[]): PLHashMap;
+export function plNumber(value: any, decimals?: number): PLNumber;
+export function plString(value?: string): PLString;
+export function plVector(...value: any[]): PLVector;
+export function reduce(init: any, fn: any, f: any): any;
+export const runtime: {
+    typeof: (v: any) => any;
+    copy: (item: any) => any;
+    'deep-copy': (item: any) => any;
+    str: (value: any) => PLString;
+    'to-json': (value: any) => PLString;
+} & {
+    '==': (a: any, b: any) => any;
+    '!=': (a: any, b: any) => any;
+    '<': (a: any, b: any) => any;
+    '<=': (a: any, b: any) => PLBool;
+    '>': (a: any, b: any) => any;
+    '>=': (a: any, b: any) => PLBool;
+} & {
+    count: (collection: any) => any;
+    contains: typeof contains;
+    map: typeof map;
+    filter: typeof filter;
+    reduce: typeof reduce;
+    slice: typeof slice$1;
+} & {
+    negate: (a: any) => any;
+    not: (a: any) => any;
+    and: (a: any, b: any) => any;
+    or: (a: any, b: any) => any;
+    '+': (a: any, b: any) => any;
+    '-': (a: any, b: any) => any;
+    '*': (a: any, b: any) => any;
+    '/': (a: any, b: any) => any;
+    get: (data: any, idx: any) => any;
+} & {
+    const: (fn: any) => () => any;
+} & Readonly<{
+    __proto__: null;
+    E: PLNumber;
+    LN2: PLNumber;
+    LN10: PLNumber;
+    LOG2E: PLNumber;
+    LOG10E: PLNumber;
+    PI: PLNumber;
+    SQRT1_2: PLNumber;
+    SQRT2: PLNumber;
+    abs: (x: any) => PLNumber;
+    sign: (x: any) => PLNumber;
+    min: (x: any, y: any) => PLNumber;
+    max: (x: any, y: any) => PLNumber;
+    floor: (x: any) => PLNumber;
+    round: (x: any) => PLNumber;
+    ceil: (x: any) => PLNumber;
+    trunc: (x: any) => PLNumber;
+    cbrt: (x: any) => PLNumber;
+    sqrt: (x: any) => PLNumber;
+    exp: (x: any) => PLNumber;
+    pow: (x: any, y: any) => PLNumber;
+    log: (x: any) => PLNumber;
+    log2: (x: any) => PLNumber;
+    log10: (x: any) => PLNumber;
+    deg2rad: (x: any) => any;
+    rad2deg: (x: any) => any;
+    sin: (x: any) => PLNumber;
+    asin: (x: any) => PLNumber;
+    asinh: (x: any) => PLNumber;
+    cos: (x: any) => PLNumber;
+    acos: (x: any) => PLNumber;
+    acosh: (x: any) => PLNumber;
+    tan: (x: any) => PLNumber;
+    atan: (x: any) => PLNumber;
+    atan2: (x: any, y: any) => PLNumber;
+    atanh: (x: any) => PLNumber;
+}> & {
+    modulo: typeof modulo;
+} & {
+    "number-2-fraction": (accuracy: any, number: any) => PLFractionNumber;
+    "fraction-2-number": (number: any) => PLNumber;
+    reciprocal: (fn: any) => PLFractionNumber;
+} & {
+    sum: (list: any) => any;
+    prod: (list: any) => any;
+    intersperse: (separator: any, list: any) => any;
+    join: (list: any) => any;
+    'join-with': (separator: any, list: any) => any;
+    'num-list': (separator: any, list: any) => any;
+    head: (list: any) => any;
+    reverse: (list: any) => PLVector;
+    slice: (list: any, start: any, end: any) => PLVector;
+    tail: (list: any) => PLVector;
+} & {
+    keys: (map: any) => PLVector;
+    values: (map: any) => PLVector;
+    "hash-map": (...list: any[]) => PLHashMap;
+} & {
+    Set: (value: any) => PLSet;
+    'set-2-list': typeof set2list;
+    'set-union': typeof union;
+    'set-diff': typeof difference;
+    'set-intersection': typeof intersection;
+    'set-symmetric-difference': typeof symmetricDifference;
+} & Readonly<{
+    __proto__: null;
+    random: () => PLNumber;
+    randomInt: (a: any, b: any) => PLNumber;
+    shuffle: (v: any) => PLVector;
+    range: (start: any, len: any, step: any) => PLVector;
+    range0: (len: any) => PLVector;
+}> & {
+    maybe: (value: any) => NothingClass | Just;
+    Nothing: NothingClass;
+};
+declare function slice$1(start: any, end: any, container: any): any;
+export function str(value: any): PLString;
+export function subtract(a: any, b: any): any;
+export function toJSON(value: any): PLString;
+export namespace utils {
+    export { unboxing };
+}
+declare function parseBool(value: any): PLBool;
+declare function plBoolConstructor(value: any): any;
+declare function parseNothing(value: any): NothingClass;
+declare function plNothingConstructor(value: any): any;
+declare function plIntegerConstructor(value: any): any;
+declare function plFloatConstructor(value: any): any;
+declare function str2plFractionNumber(str: any): PLFractionNumber;
+declare function plFractionNumberConstructor(n: any, d: any): PLFractionNumber;
+declare function plStringConstructor(value: any): any;
+declare function modulo(dividend: any, divisor: any): PLNumber;
+declare class PLSet {
+    constructor(list: any);
+    _value: any;
+    get value(): any;
+    contains(item: any): PLBool;
+    union(a: any): PLSet;
+    difference(a: any): PLSet;
+    intersection(a: any): PLSet;
+    symmetricDifference(a: any): PLSet;
+    count(): PLNumber;
+    map(fn: any): PLSet;
+    filter(fn: any): PLSet;
+    reduce(init: any, fn: any): any;
+    toJS(): any;
+    toJSON(): any;
+    toString(): string;
+    copy(): PLSet;
+    deepCopy(): PLSet;
+    debugTypeOf(): PLString;
+}
+declare namespace PLSet {
+    let kind_7: string;
+    export { kind_7 as kind };
+}
+declare function set2list(set: any): PLVector;
+declare function union(a: any, b: any): any;
+declare function difference(a: any, b: any): any;
+declare function intersection(a: any, b: any): any;
+declare function symmetricDifference(a: any, b: any): any;
+declare class Just {
+    constructor(_value: any);
+    _value: any;
+    get value(): any;
+    toJS(): any;
+    toJSON(): any;
+    toString(): string;
+    debugTypeOf(): PLString;
+}
+declare namespace Just {
+    let kind_8: string;
+    export { kind_8 as kind };
+}
+declare function unboxing(x: any): any;
+export { slice$1 as slice };

package/lib/api/parser/leaflisp/test.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/api/parser/leaflisp/test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/parser/leaflisp.d.ts

@@ -0,0 +1,2 @@
+export function processLEAFlisp(str: any): (...input: any[]) => any;
+export function processStaticLEAFlisp(str: any): any;

package/lib/api/parser/nodelogic/abstraction/index.d.ts

@@ -0,0 +1,7 @@
+import { _leaflambdagraph } from './leaflambdagraph.js';
+import { _leafspell } from './leafspell.js';
+import { _leafspelldef } from './leafspelldef.js';
+import { _leafloopyspell } from './leafloopyspell.js';
+import { _leafgraph } from './leafgraph.js';
+import { _leafanchor } from './leafanchor.js';
+export { _leaflambdagraph, _leafspell, _leafspelldef, _leafloopyspell, _leafgraph, _leafanchor };

package/lib/api/parser/nodelogic/abstraction/leafanchor.d.ts

@@ -0,0 +1,4 @@
+export namespace _leafanchor {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<undefined>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<undefined>;
+}

package/lib/api/parser/nodelogic/abstraction/leafgraph.d.ts

@@ -0,0 +1,6 @@
+export namespace _leafgraph {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{} | undefined>;
+    function _lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{} | undefined>;
+    function methods(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/abstraction/leaflambdagraph.d.ts

@@ -0,0 +1,4 @@
+export namespace _leaflambdagraph {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$Arr: any, controlflow$obj: any) => any>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/abstraction/leafloopyspell.d.ts

@@ -0,0 +1,4 @@
+export namespace _leafloopyspell {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$Arr: any, controlflow$obj: any) => any>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/abstraction/leafloopyspell.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/parser/nodelogic/abstraction/leafspell.d.ts

@@ -0,0 +1,9 @@
+export namespace _leafspell {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<any>;
+}

package/lib/api/parser/nodelogic/abstraction/leafspell.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/parser/nodelogic/abstraction/leafspelldef.d.ts

@@ -0,0 +1,5 @@
+export namespace _leafspelldef {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$Arr: any, controlflow$obj: any) => any>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+    function methods(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/common.d.ts

@@ -0,0 +1,8 @@
+export function _common_methods(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{
+    version: string;
+    nodequery: (flowinput$obj: any) => {
+        _stream: any;
+        _control: any;
+    };
+    nodemethod: (flowinput$obj: any) => {};
+}>;

package/lib/api/parser/nodelogic/dataflow/index.d.ts

@@ -0,0 +1,4 @@
+import { _leafchronosflow } from "./leafchronosflow.js";
+import { _leafmixflow } from "./leafmixflow.js";
+import { _leafgateflow } from "./leafgateflow.js";
+export { _leafchronosflow, _leafmixflow, _leafgateflow };

package/lib/api/parser/nodelogic/dataflow/leafchronosflow.d.ts

@@ -0,0 +1,4 @@
+export namespace _leafchronosflow {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => any>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/dataflow/leafgateflow.d.ts

@@ -0,0 +1,10 @@
+export namespace _leafgateflow {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/dataflow/leafmixflow.d.ts

@@ -0,0 +1,4 @@
+export namespace _leafmixflow {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => any>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/dataflow/leafmixflow.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/parser/nodelogic/datautils/bottling.d.ts

@@ -0,0 +1,11 @@
+export function doBottle(key: any, data: any, blabel?: {}): {
+    _bname: any;
+    _content: any;
+    _label: {};
+};
+export function doUnbottle(key: any, data: any, blabel?: {}): any;
+export namespace EmptyBottle {
+    export { key as _bname };
+    export { data as _content };
+    export { blabel as _label };
+}

package/lib/api/parser/nodelogic/datautils/index.d.ts

@@ -0,0 +1,7 @@
+import { _leaflabel } from "./leaflabel.js";
+import { _leafdelabel } from "./leafdelabel.js";
+import { _leafbottle } from "./leafbottle.js";
+import { _leafunbottle } from "./leafunbottle.js";
+import { _leafcrate } from "./leafcrate.js";
+import { _leafconfig } from "./leafconfig.js";
+export { _leaflabel, _leafdelabel, _leafbottle, _leafunbottle, _leafcrate, _leafconfig };

package/lib/api/parser/nodelogic/datautils/leafbottle.d.ts

@@ -0,0 +1,12 @@
+export namespace _leafbottle {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}
+import { doBottle } from './bottling.js';
+export { doBottle };

package/lib/api/parser/nodelogic/datautils/leafconfig.d.ts

@@ -0,0 +1,12 @@
+export namespace _leafconfig {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(flowinput$Arr: any, controlflow$obj: any) => {
+        _stream: any;
+        _control: any;
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+    function methods(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{
+        config: {
+            getConfigData: () => Promise<any>;
+        };
+    }>;
+}

package/lib/api/parser/nodelogic/datautils/leafcrate.d.ts

@@ -0,0 +1,7 @@
+export namespace _leafcrate {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: any;
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/datautils/leafdelabel.d.ts

@@ -0,0 +1,7 @@
+export namespace _leafdelabel {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(flowinput$Arr: any, controlflow$obj: any) => {
+        _stream: any;
+        _control: any;
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<any>;
+}

package/lib/api/parser/nodelogic/datautils/leaflabel.d.ts

@@ -0,0 +1,15 @@
+export namespace _leaflabel {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+    function methods(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{
+        _nodelut: {};
+    } | {
+        _nodelut?: undefined;
+    }>;
+}

package/lib/api/parser/nodelogic/datautils/leafunbottle.d.ts

@@ -0,0 +1,12 @@
+export namespace _leafunbottle {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}
+import { doUnbottle } from './bottling.js';
+export { doUnbottle };

package/lib/api/parser/nodelogic/elements/index.d.ts

@@ -0,0 +1,8 @@
+import { _leafdeckspade } from "./leafdeckspade.js";
+import { _leafdeckheart } from "./leafdeckheart.js";
+import { _leafdeckdiamond } from "./leafdeckdiamond.js";
+import { _leafdeckclub } from "./leafdeckclub.js";
+import { _leafgnav } from "./leafgnav.js";
+import { _leafpopupview } from "./leafpopupview.js";
+import { _leafelement } from "./leafelement.js";
+export { _leafdeckspade, _leafdeckheart, _leafdeckdiamond, _leafdeckclub, _leafgnav, _leafpopupview, _leafelement };

package/lib/api/parser/nodelogic/elements/leafdeckclub.d.ts

@@ -0,0 +1,10 @@
+export namespace _leafdeckclub {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/elements/leafdeckdiamond.d.ts

@@ -0,0 +1,10 @@
+export namespace _leafdeckdiamond {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/elements/leafdeckheart.d.ts

@@ -0,0 +1,10 @@
+export namespace _leafdeckheart {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}

package/lib/api/parser/nodelogic/elements/leafdeckspade.d.ts

@@ -0,0 +1,10 @@
+export namespace _leafdeckspade {
+    function dataflow(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<(input$objArr: any, controlflow$obj: any) => {
+        _stream: import("rxjs").Observable<any>;
+        _control: {
+            _stream: any;
+            _config: any;
+        };
+    }>;
+    function lambda(lambdactrl: any): ({ refnode, refnodedata, nodelambda, contextuallambda }?: {}) => Promise<{}>;
+}