/**
 * @author fenris
 */
type int = number;
/**
 * @author fenris
 */
type float = number;
declare class Buffer {
    constructor(x: string, modifier?: string);
    toString(modifier?: string): string;
}
declare namespace lib_plankton.base {
    /**
     * @author fenris
     */
    function environment(): string;
}
/**
 * @author fenris
 */
type type_pseudopointer<type_value> = {
    value: type_value;
};
/**
 * @author fenris
 */
declare function pseudopointer_null<type_value>(): type_pseudopointer<type_value>;
/**
 * @author fenris
 */
declare function pseudopointer_make<type_value>(value: type_value): type_pseudopointer<type_value>;
/**
 * @author fenris
 */
declare function pseudopointer_isset<type_value>(pseudopointer: type_pseudopointer<type_value>): boolean;
/**
 * @author fenris
 */
declare function pseudopointer_read<type_value>(pseudopointer: type_pseudopointer<type_value>): type_value;
/**
 * @author fenris
 */
declare function pseudopointer_write<type_value>(pseudopointer: type_pseudopointer<type_value>, value: type_value): void;
/**
 * @author fenris
 */
declare var instance_verbosity: int;
/**
 * @desc the ability to check for equality with another element of the same domain
 * @author fenris
 */
interface interface_collatable<type_value> {
    /**
     * @author fenris
     */
    _collate(value: type_value): boolean;
}
/**
 * @author fenris
 */
declare function instance_collate<type_value>(value1: (type_value & {
    _collate?: ((value: type_value) => boolean);
}), value2: type_value): boolean;
/**
 * @desc the ability to compare with another element of the same domain for determining if the first is "smaller than or equal to" the latter
 * @author fenris
 */
interface interface_comparable<type_value> {
    /**
     * @author fenris
     */
    _compare(value: type_value): boolean;
}
/**
 * @author fenris
 */
declare function instance_compare<type_value>(value1: (type_value & {
    _compare: ((value: type_value) => boolean);
}), value2: type_value): boolean;
/**
 * @desc the ability to create an exact copy
 * @author fenris
 */
interface interface_cloneable<type_value> {
    /**
     * @author fenris
     */
    _clone(): type_value;
}
/**
 * @author fenris
 */
declare function instance_clone<type_value>(value: (type_value & {
    _clone?: (() => type_value);
})): type_value;
/**
 * @author fenris
 */
interface interface_hashable {
    /**
     * @author fenris
     */
    _hash(): string;
}
/**
 * @desc the ability to generate a string out of the element, which identifies it to a high degree
 * @author fenris
 */
declare function instance_hash<type_value>(value: (type_value & {
    _hash?: (() => string);
})): string;
/**
 * @author fenris
 */
interface interface_showable {
    /**
     * @author fenris
     */
    _show(): string;
}
/**
 * @desc the ability to map the element to a textual representation (most likely not injective)
 * @author fenris
 */
declare function instance_show<type_value>(value: (type_value & {
    _show?: (() => string);
})): string;
/**
 * @author frac
 */
interface interface_decorator<type_core> {
    /**
     * @author frac
     */
    core: type_core;
}
/**
 * @author frac
 */
declare class class_observer {
    /**
     * @author frac
     */
    protected counter: int;
    /**
     * @author frac
     */
    protected actions: {
        [id: string]: (information: Object) => void;
    };
    /**
     * @author frac
     */
    protected buffer: Array<Object>;
    /**
     * @author frac
     */
    constructor();
    /**
     * @author frac
     */
    empty(): boolean;
    /**
     * @author frac
     */
    flush(): void;
    /**
     * @author frac
     */
    set(id: string, action: (information: Object) => void): void;
    /**
     * @author frac
     */
    del(id: string): void;
    /**
     * @author frac
     */
    add(action: (information: Object) => void): void;
    /**
     * @author frac
     */
    notify(information?: Object, delayed?: boolean): void;
    /**
     * @author frac
     */
    rollout(): void;
}
/**
 * @author frac
 */
/**
 * @author frac
 */
/**
 * @author frac
 */
declare class class_error extends Error {
    /**
     * @author frac
     */
    protected suberrors: Array<Error>;
    /**
     * @author frac
     */
    protected mess: string;
    /**
     * @author frac
     */
    constructor(message: string, suberrors?: Array<Error>);
    /**
     * @override
     * @author frac
     */
    toString(): string;
}
declare namespace lib_plankton.base {
    /**
     * returns the current UNIX timestamp
     *
     * @author fenris
     */
    function get_current_timestamp(rounded?: boolean): float;
    /**
     */
    function object_merge(core: Record<string, any>, mantle: Record<string, any>): Record<string, any>;
    /**
     */
    function buffer_show(buffer: Buffer, { "block_size": option_block_size, "break_char": option_break_char, "render_readable_characters": render_readable_characters, }?: {
        block_size?: int;
        break_char?: string;
        render_readable_characters?: boolean;
    }): string;
}
declare module lib_plankton.pod {
    /**
     * @author fenris
     */
    type type_pod<type_value> = {
        kind: ("empty" | "filled");
        value?: type_value;
    };
    /**
     * @author fenris
     */
    function make_empty<type_value>(): type_pod<type_value>;
    /**
     * @author fenris
     */
    function make_filled<type_value>(value: type_value): type_pod<type_value>;
    /**
     * whether the pod is filled
     *
     * @author fenris
     */
    function is_filled<type_value>(pod: type_pod<type_value>): boolean;
    /**
     * return the value, stored in the pod-wrapper
     *
     * @author fenris
     */
    function cull<type_value>(pod: type_pod<type_value>): type_value;
    /**
     * to pass on a empty-pod or to use a filled-pod
     *
     * @author fenris
     */
    function propagate<type_value, type_value_>(pod: type_pod<type_value>, function_: ((value: type_value) => type_value_)): type_pod<type_value_>;
    /**
     * @author fenris
     */
    function distinguish<type_value, type_result>(pod: type_pod<type_value>, function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result;
    /**
     */
    function show<type_value>(pod: type_pod<type_value>, options?: {
        show_value?: ((value: type_value) => string);
    }): string;
}
declare module lib_plankton.pod {
    /**
     */
    class class_pod<type_value> {
        private subject;
        constructor(subject: type_pod<type_value>);
        tear(): type_pod<type_value>;
        static empty<type_value>(): class_pod<type_value>;
        static filled<type_value>(value: type_value): class_pod<type_value>;
        is_empty(): boolean;
        is_filled(): boolean;
        cull(): type_value;
        show(show_value?: any): string;
        toString(): string;
        propagate<type_value_>(function_: ((value: type_value) => type_value_)): class_pod<type_value_>;
        distinguish<type_result>(function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result;
    }
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    interface interface_code<type_from, type_to> {
        /**
         * @author fenris
         */
        encode(x: type_from): type_to;
        /**
         * @author fenris
         */
        decode(x: type_to): type_from;
    }
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    type type_code<type_from, type_to> = {
        /**
         * @author fenris
         */
        encode: (x: type_from) => type_to;
        /**
         * @author fenris
         */
        decode: (x: type_to) => type_from;
    };
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    function inverse_encode<type_from, type_to>(decode: (to: type_to) => type_from, to: type_to): type_from;
    /**
     * @author fenris
     */
    function inverse_decode<type_from, type_to>(encode: (from: type_from) => type_to, from: type_from): type_to;
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    class class_code_inverse<type_from, type_to> implements interface_code<type_to, type_from> {
        /**
         * @author fenris
         */
        protected subject: interface_code<type_from, type_to>;
        /**
         * @author fenris
         */
        constructor(subject: interface_code<type_from, type_to>);
        /**
         * @implementation
         * @author fenris
         */
        encode(to: type_to): type_from;
        /**
         * @implementation
         * @author fenris
         */
        decode(from: type_from): type_to;
    }
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    function pair_encode<type_from, type_between, type_to>(encode_first: (from: type_from) => type_between, encode_second: (between: type_between) => type_to, from: type_from): type_to;
    /**
     * @author fenris
     */
    function pair_decode<type_from, type_between, type_to>(decode_first: (between: type_between) => type_from, decode_second: (to: type_to) => type_between, to: type_to): type_from;
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    class class_code_pair<type_from, type_between, type_to> implements interface_code<type_from, type_to> {
        /**
         * @author fenris
         */
        protected first: interface_code<type_from, type_between>;
        /**
         * @author fenris
         */
        protected second: interface_code<type_between, type_to>;
        /**
         * @author fenris
         */
        constructor(first: interface_code<type_from, type_between>, second: interface_code<type_between, type_to>);
        /**
         * @implementation
         * @author fenris
         */
        encode(from: type_from): type_to;
        /**
         * @implementation
         * @author fenris
         */
        decode(to: type_to): type_from;
    }
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    function chain_encode(encode_links: Array<(from: any) => any>, from: any): any;
    /**
     * @author fenris
     */
    function chain_decode(decode_links: Array<(to: any) => any>, to: any): any;
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    class class_code_chain implements interface_code<any, any> {
        /**
         * @author fenris
         */
        protected links: Array<interface_code<any, any>>;
        /**
         * @author fenris
         */
        constructor(links: Array<interface_code<any, any>>);
        /**
         * @implementation
         * @author fenris
         */
        encode(from: any): any;
        /**
         * @implementation
         * @author fenris
         */
        decode(to: any): any;
    }
}
declare namespace lib_plankton.code {
    /**
     * @author Christian Fraß <frass@greenscale.de>
     */
    type type_flatten_from = Array<{
        [name: string]: any;
    }>;
    /**
     * @author Christian Fraß <frass@greenscale.de>
     */
    type type_flatten_to = {
        keys: Array<string>;
        data: Array<Array<any>>;
    };
    /**
     * @author Christian Fraß <frass@greenscale.de>
     */
    function flatten_encode(from: type_flatten_from, keys?: Array<string>): type_flatten_to;
    /**
     * @author Christian Fraß <frass@greenscale.de>
     */
    function flatten_decode(to: type_flatten_to): type_flatten_from;
}
declare namespace lib_plankton.code {
    /**
     * @author fenris
     */
    class class_code_flatten implements interface_code<type_flatten_from, type_flatten_to> {
        /**
         * @author fenris
         */
        constructor();
        /**
         * @implementation
         * @author fenris
         */
        encode(x: type_flatten_from): type_flatten_to;
        /**
         * @implementation
         * @author fenris
         */
        decode(x: type_flatten_to): type_flatten_from;
    }
}
declare namespace lib_plankton.json {
    /**
     */
    type type_source = any;
    /**
     */
    type type_target = string;
    /**
     * @author fenris
     */
    export function encode(source: type_source, options?: {
        formatted?: boolean;
    }): type_target;
    /**
     * @author fenris
     */
    export function decode(target: type_target): type_source;
    /**
     * @author fenris
     */
    export function implementation_code(): lib_plankton.code.type_code<type_source, type_target>;
    export {};
}
declare namespace lib_plankton.json {
    /**
     * @author fenris
     */
    class class_json implements lib_plankton.code.interface_code<any, string> {
        /**
         * @author fenris
         */
        constructor();
        /**
         * @implementation
         * @author fenris
         */
        encode(x: any): string;
        /**
         * @implementation
         * @author fenris
         */
        decode(x: string): any;
    }
}
/**
 * might be completely obsolete
 */
declare namespace lib_plankton.call {
    /**
     * @author fenris
     */
    type type_promise<type_result, type_reason> = Promise<type_result>;
    /**
     * @author fenris
     */
    function promise_reject<type_result, type_reason>(reason: type_reason): type_promise<type_result, type_reason>;
    /**
     * @author fenris
     */
    function promise_resolve<type_result, type_reason>(result: type_result): type_promise<type_result, type_reason>;
    /**
     * @author fenris
     */
    function promise_make<type_result, type_reason>(executor: (resolve: ((result?: type_result) => void), reject: ((reason?: type_reason) => void)) => void): type_promise<type_result, type_reason>;
    /**
     * @author fenris
     */
    function promise_then_close<type_result, type_reason>(promise: type_promise<type_result, type_reason>, resolver: ((result: type_result) => void), rejector: ((reason: type_reason) => void)): void;
    /**
     * @author fenris
     */
    function promise_then_append<type_result, type_reason, type_result_>(promise: type_promise<type_result, type_reason>, resolver: ((result: type_result) => type_promise<type_result_, type_reason>), rejector?: ((reason: type_reason) => type_promise<type_result_, type_reason>)): type_promise<type_result_, type_result>;
    /**
     * @author fenris
     */
    function promise_all<type_result, type_reason>(promises: Array<type_promise<type_result, type_reason>>): type_promise<Array<type_result>, type_reason>;
    /**
     * @author fenris
     */
    function promise_chain<type_result, type_reason>(promises: (Array<(input: type_result) => type_promise<type_result, type_reason>>), start?: type_result): type_promise<type_result, type_reason>;
    /**
     * @author fenris
     */
    function promise_condense<type_element, type_reason>(promises: Array<() => type_promise<type_element, type_reason>>): type_promise<Array<type_element>, type_reason>;
    /**
     * @author fenris
     */
    function promise_group<type_reason>(promises: Record<string, (() => type_promise<any, type_reason>)>, options?: {
        serial?: boolean;
    }): type_promise<Record<string, any>, type_reason>;
    /**
     * @author fenris
     */
    function promise_wrap<type_result_inner, type_result_outer, type_reason>(promise: type_promise<type_result_inner, type_reason>, transformator_result: ((reason: type_result_inner) => type_result_outer), transformator_reason?: ((reason: type_reason) => type_reason)): type_promise<type_result_outer, type_reason>;
    /**
     * @author fenris
     */
    /**
     * @author fenris
     */
    /**
     * @author fenris
     */
    function promise_attach<type_reason>(state: Record<string, any>, promise: type_promise<any, type_reason>, name: string): type_promise<Record<string, any>, type_reason>;
    /**
     * @author fenris
     */
    function promise_delay<type_result, type_reason>(promise: type_promise<type_result, type_reason>, delay: int): type_promise<type_result, type_reason>;
}
/**
 * initializer might be obsolete, since promises are reusable after having been resolved or rejected
 */
declare namespace lib_plankton.call {
    /**
     * @author fenris
     */
    enum enum_initializer_state {
        initial = 0,
        waiting = 1,
        successful = 2,
        failed = 3
    }
    /**
     * @author fenris
     */
    type type_initializer<type_result, type_reason> = {
        fetcher: (() => type_promise<type_result, type_reason>);
        state?: enum_initializer_state;
        queue: Array<{
            resolve: ((result?: type_result) => void);
            reject: ((reason?: type_reason) => void);
        }>;
        result?: type_result;
        reason?: type_reason;
    };
    /**
     * @author fenris
     */
    function initializer_make<type_result, type_reason>(fetcher: (() => type_promise<type_result, type_reason>)): type_initializer<type_result, type_reason>;
    /**
     * @author fenris
     */
    function initializer_reset<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): void;
    /**
     * @author fenris
     */
    function initializer_state<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): enum_initializer_state;
    /**
     * @author fenris
     */
    function initializer_get<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): type_promise<type_result, type_reason>;
}
declare namespace lib_plankton.call {
    /**
     * @author fenris
     */
    type type_deferral<type_input, type_output> = {
        representation: (input: type_input) => Promise<type_output>;
    };
    /**
     * @author fenris
     * @desc activates the deferral and handles its output according to a given procedure
     * @param {(value : type_value)=>void} procedure a function which receives the output of the deferral as argument
     */
    function deferral_use<type_input, type_output>(deferral: type_deferral<type_input, type_output>, input: type_input, procedure: (output: type_output) => void): void;
    /**
     * @author fenris
     * @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject")
     */
    function deferral_make<type_input, type_output>(handler: (input: type_input, convey: (output: type_output) => void) => void): type_deferral<type_input, type_output>;
    /**
     * @author fenris
     * @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject")
     */
    function deferral_wrap<type_input, type_output>(function_: (input: type_input) => type_output): type_deferral<type_input, type_output>;
    /**
     * @author fenris
     */
    function deferral_id<type_value>(): type_deferral<type_value, type_value>;
    /**
     * @author fenris
     */
    function deferral_const<type_value>(value: type_value): type_deferral<type_value, type_value>;
    /**
     * @author fenris
     */
    function deferral_delay<type_output>(output: type_output, delay: int): type_deferral<any, type_output>;
    /**
     * @author fenris
     * @desc connects two deferrals to form a new one; the output of the first is taken as input for the second
     *     (similar to "Promise.then" when passing a function which returns a new promise)
     * @param {type_deferral<type_value1>} first a simple deferral
     * @param {(value1 : type_value1)=>type_deferral<type_value2>} second a function depending from a value returning a deferral
     */
    function deferral_compose_serial<type_input, type_between, type_output>(first: type_deferral<type_input, type_between>, second: type_deferral<type_between, type_output>): type_deferral<type_input, type_output>;
    /**
     * @author fenris
     */
    function deferral_compose_parallel<type_input, type_output_left, type_output_right>({ "left": deferral_left, "right": deferral_right, }: {
        left: type_deferral<type_input, type_output_left>;
        right: type_deferral<type_input, type_output_right>;
    }): type_deferral<type_input, {
        left: type_output_left;
        right: type_output_right;
    }>;
    /**
     * @author fenris
     * @desc repeatedly applied serial composition
     */
    function deferral_chain<type_value>(members: Array<type_deferral<type_value, type_value>>): type_deferral<type_value, type_value>;
    /**
     * @author fenris
     */
}
declare namespace lib_plankton.call {
    /**
     * @author fenris
     */
    class class_deferral<type_input, type_output> {
        /**
         * @author fenris
         */
        private subject;
        /**
         * @author fenris
         */
        private constructor();
        /**
         * @author fenris
         */
        private static _cram;
        /**
         * @author fenris
         */
        private static _tear;
        /**
         * @author fenris
         */
        static make<type_input, type_output>(handler: (input: type_input, convey: (value: type_output) => void) => void): class_deferral<type_input, type_output>;
        /**
         * @author fenris
         */
        use(input: type_input, procedure: (value: type_output) => void): void;
        /**
         * @author fenris
         */
        compose_serial<type_output_>(second: class_deferral<type_output, type_output_>): class_deferral<type_input, type_output_>;
        /**
         * @author fenris
         */
        static chain<type_value>(members: Array<class_deferral<type_value, type_value>>): class_deferral<type_value, type_value>;
        /**
         * @author fenris
         */
        static wrap<type_input, type_output>(function_: (input: type_input) => type_output): class_deferral<type_input, type_output>;
        /**
         * @author fenris
         */
        static const_<type_value>(value: type_value): class_deferral<type_value, type_value>;
        /**
         * @author fenris
         */
        static delay<type_output>(output: type_output, delay: int): class_deferral<any, type_output>;
    }
}
declare namespace lib_plankton.call {
    /**
     * converts the "arguments"-map into an array
     *
     * @param {Object} args
     * @author fenris
     */
    export function args2list(args: any): Array<any>;
    /**
     * just the empty function; useful for some callbacks etc.
     *
     * @author fenris
     */
    export function nothing(): void;
    /**
     * just the identity; useful for some callbacks etc.; defined as function instead of const for using type parameters
     *
     * @author fenris
     */
    export function id<type_value>(x: type_value): type_value;
    /**
     * just the identity; useful for some callbacks etc.
     *
     * @author fenris
     */
    export function const_<type_value>(x: type_value): ((y: any) => type_value);
    /**
     * composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)
     *
     * @param {function} function_f
     * @param {function} function_g
     * @author fenris
     */
    export function compose<type_x, type_y, type_z>(function_f: ((type_x: any) => type_y), function_g: ((type_y: any) => type_z)): ((value: type_x) => type_z);
    /**
     * transforms a function with sequential input to a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)
     *
     * @param {function} f
     * @return {function} the currified version of the in put function
     * @author fenris
     */
    export function curryfy(f: Function): Function;
    /**
     * @author fenris
     */
    export function convey(value: any, functions: Array<Function>): any;
    /**
     */
    class class_value_wrapper<type_value> {
        /**
         */
        private value;
        /**
         */
        constructor(value: type_value);
        /**
         */
        convey<type_value_result>(function_: ((value: type_value) => type_value_result)): class_value_wrapper<type_value_result>;
        /**
         */
        cull(): type_value;
    }
    /**
     */
    export function wrap<type_value>(value: type_value): class_value_wrapper<type_value>;
    /**
     * @author fenris
     */
    export function timeout(procedure: (() => void), delay_in_seconds: float): int;
    /**
     * @author fenris
     */
    export function loop(procedure: (() => void), delay_in_seconds: float): int;
    /**
     * Promise version of "setTimeout"
     *
     * @author fenris
     */
    export function defer<type_result>(seconds: float, action: (() => type_result)): Promise<type_result>;
    /**
     * a definition for a value being "defined"
     *
     * @author neuc
     */
    export function is_def<type_value>(obj: type_value, options?: {
        null_is_valid?: boolean;
    }): boolean;
    /**
     * returns the value if set and, when a type is specified, if the type is correct, if not return default_value
     *
     * @author neuc
     */
    export function def_val(value: any, default_value: any, options?: {
        type?: (null | string);
        null_is_valid?: boolean;
    }): any;
    /**
     * provides the call for an attribute of a class as a regular function; useful for processing lists of objects
     *
     * @param {string} name the name of the attribute
     * @return {function}
     * @author fenris
     */
    export function attribute<type_object, type_attribute>(name: string): ((object: type_object) => type_attribute);
    /**
     * provides a method of a class as a regular function; useful for processing lists of objects
     *
     * @param {string} name the name of the method
     * @return {function}
     * @author fenris
     */
    export function method<type_object, type_output>(name: string): ((object: type_object) => type_output);
    /**
     * @author fenris
     */
    export type type_coproduct = {
        kind: string;
        data?: any;
    };
    /**
     * @author fenris
     */
    export function distinguish<type_output>(coproduct: type_coproduct, handlers: Record<string, ((data?: any) => type_output)>, options?: {
        fallback?: (null | ((coproduct?: type_coproduct) => type_output));
    }): type_output;
    /**
     */
    export function try_catch_wrap<type_value>(get_value: (() => type_value)): {
        value: (null | type_value);
        error: (null | any);
    };
    /**
     */
    export function try_catch_wrap_async<type_value>(get_value: (() => Promise<type_value>)): Promise<{
        value: (null | type_value);
        error: (null | any);
    }>;
    /**
     */
    export function sleep(seconds: float): Promise<void>;
    /**
     */
    export function null_prop<type_value_from, type_value_to>(value_from: (null | type_value_from), function_: ((value: type_value_from) => type_value_to)): (null | type_value_to);
    export {};
}
declare namespace lib_plankton.call {
    /**
     */
    type type_queue_item<type_data, type_result> = {
        data: type_data;
        resolve: ((result: type_result) => void);
        reject: ((reason: any) => void);
    };
    /**
     */
    export type type_queue<type_data, type_result> = {
        handler: ((data: type_data) => Promise<type_result>);
        items: Array<type_queue_item<type_data, type_result>>;
        busy: boolean;
        paused: boolean;
    };
    /**
     */
    export function queue_make<type_data, type_result>(handler: ((data: type_data) => Promise<type_result>)): type_queue<type_data, type_result>;
    /**
     */
    export function queue_toggle_paused<type_data, type_result>(queue_subject: type_queue<type_data, type_result>, { "mode": mode, }?: {
        mode?: (null | boolean);
    }): void;
    /**
     */
    export function queue_add<type_data, type_result>(queue_subject: type_queue<type_data, type_result>, data: type_data, resolve: ((result: type_result) => void), reject: ((reason: any) => void)): void;
    export {};
}
declare namespace lib_plankton.file {
    /**
     * @author fenris
     */
    function read(path: string): Promise<string>;
    /**
     * @author fenris
     */
    function write(path: string, content: string): Promise<void>;
    /**
     * @author fenris
     */
    function blob_read_text(blob: Blob): lib_plankton.call.type_promise<string, Error>;
    /**
     * @author fenris
     */
    function blob_read_arraybuffer(blob: Blob): lib_plankton.call.type_promise<ArrayBuffer, Error>;
    /**
     * @author fenris
     */
    function blob_read_dataurl(blob: Blob): lib_plankton.call.type_promise<string, Error>;
    /**
     * @author fenris
     */
    function blob_write_text(text: string): lib_plankton.call.type_promise<Blob, Error>;
}
declare namespace lib_plankton.email {
    /**
     */
    function send(smtp_credentials: {
        host: string;
        port: int;
        username: string;
        password: string;
    }, sender: string, receivers: Array<string>, subject: string, content: string): Promise<void>;
}
declare namespace lib_plankton.log {
    /**
     */
    enum enum_level {
        debug = 0,
        info = 1,
        notice = 2,
        warning = 3,
        error = 4
    }
    /**
     */
    type type_entry = {
        level: enum_level;
        incident: string;
        tags: Array<string>;
        details: any;
    };
    /**
     */
    type type_channel_description = lib_plankton.call.type_coproduct;
    /**
     */
    type type_channel_logic = {
        send: ((entry: type_entry) => void);
    };
    /**
     */
    type type_logger_data = Array<type_channel_description>;
    /**
     */
    type type_logger_logic = Array<type_channel_logic>;
    /**
     */
    type type_format_definition = ({
        kind: "jsonl";
        data: {
            structured: boolean;
        };
    } | {
        kind: "human_readable";
        data: {};
    });
}
declare namespace lib_plankton.log {
    /**
     */
    function level_order(level1: enum_level, level2: enum_level): boolean;
    /**
     */
    function level_show(level: enum_level, { "abbreviated": option_abbreviated, }?: {
        abbreviated?: boolean;
    }): string;
    /**
     */
    function level_decode(level_string: string): enum_level;
}
declare namespace lib_plankton.log {
    /**
     * @todo use label
     */
    function get_logger_logic(logger_data: type_logger_data): type_logger_logic;
    /**
     */
    function format_entry(format_definition: type_format_definition, entry: type_entry): string;
    /**
     */
    function parse_format_definition(format_definition_raw: any): type_format_definition;
}
declare namespace lib_plankton.log.channel.filtered {
    /**
     */
    type type_predicate = ((entry: type_entry) => boolean);
    /**
     */
    type type_subject = {
        /**
         * @todo check if it has to be logic
         */
        core: type_channel_logic;
        predicate: type_predicate;
    };
    /**
     */
    function predicate_incident(substring: string): type_predicate;
    /**
     */
    function predicate_level(threshold: enum_level): type_predicate;
    /**
     */
    function predicate_tag(tag: string): type_predicate;
    /**
     * combines other predicates in disjunctive normal form
     */
    function predicate_complex(definition: Array<Array<{
        mode: boolean;
        item: type_predicate;
    }>>): type_predicate;
    /**
     */
    function send(subject: type_subject, entry: type_entry): void;
    /**
     */
    function logic(subject: type_subject): type_channel_logic;
}
declare namespace lib_plankton.log.channel.minlevel {
    /**
     */
    type type_subject = {
        /**
         * @todo check if it has to be logic
         */
        core: type_channel_logic;
        threshold: enum_level;
    };
    /**
     */
    function send(subject: type_subject, entry: type_entry): void;
    /**
     */
    function logic(subject: type_subject): type_channel_logic;
}
/**
 * output for writing log entries to web console
 */
declare namespace lib_plankton.log.channel.console_ {
    /**
     */
    type type_subject = {};
    /**
     * @todo tags
     */
    function send(subject: type_subject, entry: type_entry): void;
    /**
     */
    function logic(subject: type_subject): type_channel_logic;
}
declare namespace lib_plankton.log {
    /**
     */
    function get_channel_logic(channel_description: type_channel_description): type_channel_logic;
}
declare namespace lib_plankton.log {
    /**
     */
    function default_logger(): type_logger_data;
}
declare namespace lib_plankton.log {
    /**
     */
    function set_main_logger(logger_data: type_logger_data): void;
    /**
     * consumes a log entry, i.e. sends it to all channels
     */
    function send_(logger: type_logger_logic, entry: type_entry): void;
    /**
     * [convenience]
     *
     * @todo rename to "send"
     */
    function debug_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     *
     * @todo rename to "info"
     */
    function info_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     *
     * @todo rename to "notice"
     */
    function notice_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     *
     * @todo rename to "warning"
     */
    function warning_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     *
     * @todo rename to "error"
     */
    function error_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     */
    function _send(entry: type_entry): void;
    /**
     * [convenience]
     */
    function _debug(incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     */
    function _info(incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     */
    function _notice(incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     */
    function _warning(incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     */
    function _error(incident: string, { "tags": option_tags, "details": option_details, }?: {
        tags?: Array<string>;
        details?: any;
    }): void;
    /**
     * [convenience]
     *
     * @deprecated use ._debug instead!
     */
    function debug(incident: string, details?: any, tags?: Array<string>): void;
    /**
     * [convenience]
     *
     * @deprecated use ._info instead!
     */
    function info(incident: string, details?: any, tags?: Array<string>): void;
    /**
     * [convenience]
     *
     * @deprecated use ._notice instead!
     */
    function notice(incident: string, details?: any, tags?: Array<string>): void;
    /**
     * [convenience]
     *
     * @deprecated use ._warning instead!
     */
    function warning(incident: string, details?: any, tags?: Array<string>): void;
    /**
     * [convenience]
     *
     * @deprecated use ._error instead!
     */
    function error(incident: string, details?: any, tags?: Array<string>): void;
}
declare namespace lib_plankton.object {
    /**
     * @author fenris
     * @deprecated use the "??" operator instead
     */
    function fetch<type_value>(object: Object, fieldname: string, options?: {
        fallback?: type_value;
        escalate?: boolean;
    }): type_value;
    /**
     */
    function map<type_from, type_to>(object_from: Record<string, type_from>, transformator: ((value_from: type_from, key?: string) => type_to)): Record<string, type_to>;
    /**
     * gibt ein Objekt mit bestimmten Einträgen des Eingabe-Objekts zurück
     */
    function filter<type_value>(object_from: Record<string, type_value>, predicate: ((value_from: type_value, key?: string) => boolean)): Record<string, type_value>;
    /**
     * wandelt ein Array mit Einträgen der Form {key,value} in ein entsprechendes Objekt um
     *
     * @deprecated use Object.fromEntries instead!
     */
    function from_array<type_value>(array: Array<{
        key: string;
        value: type_value;
    }>): Record<string, type_value>;
    /**
     * wandelt ein Objekt in ein entsprechendes Array mit Einträgen der Form {key,value} um
     *
     * @deprecated use Object.entries insetad!
     */
    function to_array<type_value>(object: Record<string, type_value>): Array<{
        key: string;
        value: type_value;
    }>;
    /**
     * gibt eine Liste von Schlüsseln eines Objekts zurück
     *
     * @deprecated use Object.keys instead!
     */
    function keys(object: Record<string, any>): Array<string>;
    /**
     * gibt eine Liste von Werten eines Objekts zurück
     *
     * @deprecated use Object.values instead!
     */
    function values<type_value>(object: Record<string, type_value>): Array<type_value>;
    /**
     * liest ein Baum-artiges Objekt an einer bestimmten Stelle aus
     */
    function path_read<type_value>(object: Object, path: string, options?: {
        fallback?: type_value;
        escalate?: boolean;
    }): type_value;
    /**
     * schreibt einen Wert an eine bestimmte Stelle in einem Baum-artigen Objekt
     */
    function path_write<type_value>(object: Object, path: string, value: type_value, construct?: boolean): void;
    /**
     * prüft ob ein Objekt einem bestimmten Muster entspricht
     *
     * @deprecated not very useful
     */
    function matches<type_value_object, type_value_pattern>(object: Record<string, type_value_object>, pattern: Record<string, type_value_pattern>, options?: {
        collate?: ((value_pattern: type_value_pattern, value_object: type_value_object) => boolean);
    }): boolean;
    /**
     * erzeugt eine Projektion eines Baum-artigen Objekts in ein Listen-artiges Objekt
     */
    function flatten(value: any, options?: {
        separator?: string;
        key_for_array_element?: ((index: int) => string);
    }): Record<string, any>;
    /**
     * @deprecated use Object.assign instead!
     */
    function clash(x: Record<string, any>, y: Record<string, any>, options?: {
        overwrite?: boolean;
        hooks?: {
            existing?: ((key?: string, value_old?: any, value_new?: any) => void);
        };
    }): Record<string, any>;
    /**
     * @deprecated use Object.assign instead!
     */
    function patch(core: (null | Record<string, any>), mantle: (null | Record<string, any>), options?: {
        deep?: boolean;
        path?: (null | string);
    }): void;
    /**
     * @deprecated use Object.assign instead!
     */
    function patched(core: Record<string, any>, mantle: Record<string, any>, options?: {
        deep?: boolean;
    }): Record<string, any>;
    /**
     * @deprecated use Object.assign instead!
     */
    function attached(object: Record<string, any>, key: string, value: any): Record<string, any>;
    /**
     * @author fenris
     */
    function copy(object: Record<string, any>): Record<string, any>;
}
declare namespace lib_plankton.pair {
    /**
     */
    type type_pair<type_first, type_second> = {
        first: type_first;
        second: type_second;
    };
}
declare namespace lib_plankton.pair {
    /**
     */
    function swap<type_first, type_second>(pair: type_pair<type_first, type_second>): type_pair<type_second, type_first>;
    /**
     */
    function show<type_first, type_second>(pair: type_pair<type_first, type_second>, options?: {
        show_first?: ((first: type_first) => string);
        show_second?: ((second: type_second) => string);
    }): string;
}
declare namespace lib_plankton.list {
    /**
     */
    type type_separation<type_element> = {
        yes: Array<type_element>;
        no: Array<type_element>;
    };
    /**
     */
    type type_result_max<type_element, type_value> = (null | {
        index: int;
        element: type_element;
        value: type_value;
    });
}
declare namespace lib_plankton.list {
    /**
     * returns a certain list of integer numbers
     */
    function range(from: int, to: int, options?: {
        step?: int;
    }): Array<int>;
    /**
     * returns a certain list of consecutiv integer numbers, beginning with 0
     */
    function sequence(length: int): Array<int>;
    /**
     */
    function from_iterator<type_element>(iterator: Iterator<type_element>): Array<type_element>;
    /**
     */
    function is_empty<type_element>(list: Array<type_element>): boolean;
    /**
     * combines two lists into one
     *
     * @param {boolean} [options.cut] whether the result list will be as long as the shortest input list or an exception is thrown if they have different lengths; default: true
     */
    function zip<type_element_first, type_element_second>(list_first: Array<type_element_first>, list_second: Array<type_element_second>, options?: {
        cut?: boolean;
    }): Array<lib_plankton.pair.type_pair<type_element_first, type_element_second>>;
    /**
     * checks whether two lists are equal
     *
     * @todo define common function "equals" and default predicate to
     */
    function equals<type_element>(list1: Array<type_element>, list2: Array<type_element>, options?: {
        collate_element?: ((element1: type_element, element2: type_element) => boolean);
    }): boolean;
    /**
     * creates a list with the elements from the input list, which fulfil a certain predicate (~ filter)
     */
    function keep<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): Array<type_element>;
    /**
     * creates a list with the elements from the input list, which do not fulfil a certain predicate (~ dual filter)
     */
    function drop<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): Array<type_element>;
    /**
     */
    function filter_inplace<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): void;
    /**
     * returns a list with no duplicates (like unix' "unique")
     */
    function cleaned<type_element>(list: Array<type_element>, options?: {
        collate_element?: ((x: type_element, y: type_element) => boolean);
    }): Array<type_element>;
    /**
     * creates a binary partition of the list according to a given predicate
     */
    function separate<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): type_separation<type_element>;
    /**
     */
    function clone<type_element>(list: Array<type_element>): Array<type_element>;
    /**
     */
    function reversed<type_element>(list: Array<type_element>): Array<type_element>;
    /**
     * @todo use Array.toSorted?
     */
    function sorted<type_element>(list: Array<type_element>, options: {
        compare_element?: ((element1: type_element, element2: type_element) => boolean);
    }): Array<type_element>;
    /**
     * die Liste in gleich große Blöcke zerlegen
     */
    function chop<type_element>(list: Array<type_element>, chunk_size: int): Array<Array<type_element>>;
    /**
     */
    function group<type_element>(list: Array<type_element>, collate_element: ((x: type_element, y: type_element) => boolean)): Array<Array<type_element>>;
    /**
     */
    function has<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): boolean;
    /**
     * @deprecate use Array.includes or Array.some
     */
    function contains<type_element>(list: Array<type_element>, element: type_element, options: {
        collate_element?: ((element1: type_element, element2: type_element) => boolean);
    }): boolean;
    /**
     * retrieves the element and its index of the list, which has the maximum value
     */
    function max<type_element, type_value>(list: Array<type_element>, target_function: ((element: type_element) => type_value), { "compare_value": compare_value, }?: {
        compare_value?: ((value1: type_value, value2: type_value) => boolean);
    }): type_result_max<type_element, type_value>;
    /**
     * retrieves the element and its index of the list, which has the mininum value
     */
    function min<type_element, type_value>(list: Array<type_element>, target_function: (element: type_element) => type_value, options: {
        compare_value: ((value1: type_value, value2: type_value) => boolean);
    }): type_result_max<type_element, type_value>;
    /**
     * implements the idea of arithmetic distribution like in "(a+b)·(c+d) = (a·c)+(a·d)+(b·c)+(b·d)"
     * 		example: distribute([[1,2],[3],[4,5,6]]) = [[1,3,4],[1,3,5],[1,3,6],[2,3,4],[2,3,5],[2,3,6]]
     */
    function distribute<type_element>(lists: Array<Array<type_element>>): Array<Array<type_element>>;
    /**
     */
    function contrast<type_left, type_right>(list_left: Array<type_left>, extract_key_left: ((left: type_left) => string), list_right: Array<type_right>, extract_key_right: ((right: type_right) => string)): {
        both: Array<{
            key: string;
            left: type_left;
            right: type_right;
        }>;
        only_left: Array<{
            key: string;
            left: type_left;
        }>;
        only_right: Array<{
            key: string;
            right: type_right;
        }>;
    };
}
declare namespace lib_plankton.conf {
    /**
     */
    type type_schema = ({
        enum?: Array<any>;
        default?: (null | any);
        description?: string;
    } | {
        type: "null";
        description?: string;
    } | {
        type: "boolean";
        nullable?: boolean;
        enum?: Array<boolean>;
        default?: (null | boolean);
        description?: string;
    } | {
        type: "integer";
        nullable?: boolean;
        enum?: Array<int>;
        default?: (null | int);
        description?: string;
    } | {
        type: "number";
        nullable?: boolean;
        enum?: Array<number>;
        default?: (null | number);
        description?: string;
    } | {
        type: "string";
        nullable?: boolean;
        enum?: Array<string>;
        default?: (null | string);
        description?: string;
    } | {
        type: "array";
        nullable?: boolean;
        items: type_schema;
        enum?: Array<Array<any>>;
        default?: (null | Array<any>);
        description?: string;
    } | {
        type: "object";
        nullable?: boolean;
        properties?: Record<string, type_schema>;
        required?: Array<string>;
        additionalProperties?: (false | type_schema);
        enum?: Array<Record<string, any>>;
        default?: (Record<string, any> | null);
        description?: string;
    } | {
        anyOf: Array<type_schema>;
        default?: any;
    } | {
        allOf: Array<type_schema>;
    } | {
        oneOf: Array<type_schema>;
    } | {
        not: type_schema;
    });
    /**
     */
    type type_sheet<type_content> = {
        version: (null | string);
        content: type_content;
    };
    /**
     */
    type type_report = {
        incident: string;
        details: Record<string, any>;
    };
    /**
     */
    type type_adaption<type_result> = {
        reports: Array<type_report>;
        result: lib_plankton.pod.type_pod<type_result>;
    };
    /**
     */
    type type_migration<type_from, type_to> = (null | {
        target: string;
        function: ((content: type_from) => type_to);
    });
}
declare namespace lib_plankton.conf {
    /**
     */
    function refine<type_result>(schema: type_schema, content: any): type_result;
    /**
     * @deprecated
     */
    function load<type_result>(schema: type_schema, path: (null | string)): Promise<type_result>;
    /**
     */
    function load_versioned(path: string, get_schema: ((version: string) => type_schema), migrations: Record<string, type_migration<any, any>>): Promise<type_sheet<any>>;
}
declare var plain_text_to_html: (text: string) => string;
/**
 * @desc makes a valid
 */
declare var format_sentence: (str: string, rtl?: boolean, caseSense?: boolean) => string;
declare var fill_string_template: (template_string: string, object: any, fabric: Function, delimiter: string, default_string: string, sloppy: boolean) => string;
declare var make_string_template: (_template: string, _fabrics?: Object) => (object: {
    [key: string]: string;
}) => string;
declare var make_eml_header: (object: {
    [key: string]: string;
}) => string;
declare var make_eml_body: Object;
declare namespace lib_plankton.string {
    /**
     * @author neuc,frac
     */
    function empty(str: string): boolean;
    /**
     * @desc returns a unique string
     * @param {string} prefix an optional prefix for the generated string
     * @return {string}
     * @author fenris
     */
    function generate(prefix?: string): string;
    /**
     * @author fenris
     */
    function join(parts: Array<string>, glue?: string): string;
    /**
     * @desc splits a string, but returns an empty list, if the string is empty
     * @param {string} chain
     * @param {string} separator
     * @return {Array<string>}
     * @author fenris
     */
    function split(chain: string, separator: string): Array<string>;
    /**
     * @author neu3no
     */
    function explode(str: string, needle: string, max: int): Array<string>;
    /**
     * @desc concats a given word with itself n times
     * @param {string} word
     * @param {int}
     * @return {string}
     * @author fenris
     */
    function repeat(word: string, count: int): string;
    /**
     * @desc lengthens a string by repeatedly appending or prepending another string
     * @param {string} word the string to pad
     * @param {int} length the length, which the result shall have
     * @param {string} symbol the string, which will be added (multiple times)
     * @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false
     * @return {string} the padded string
     * @author fenris
     */
    function pad(word: string, length: int, symbol?: string, mode?: string): string;
    /**
     * @desc checks if a given string conttains a certain substring
     * @param {string} string
     * @param {string} part
     * @return {boolean}
     * @author fenris
     */
    function contains(chain: string, part: string): boolean;
    /**
     * @desc checks if a given string starts with a certain substring
     * @param {string} string
     * @param {string} part
     * @return {boolean}
     * @author fenris
     */
    function startsWith(chain: string, part: string): boolean;
    /**
     * @desc checks if a given string ends with a certain substring
     * @param {string} string
     * @param {string} part
     * @return {boolean}
     * @author fenris
     */
    function endsWith(chain: string, part: string): boolean;
    /**
     * @desc count the occourrences of a string in a string
     * @param string haystack_string the string wich should be examined
     * @param string needle_string the string which should be counted
     * @author neuc
     */
    function count_occourrences(haystack_string: string, needle_string: string, check_escape: boolean): int;
    /**
     * @author fenris
     */
    function replace(str: string, replacements: Array<{
        from: string;
        to: string;
    }>, options?: {}): string;
    /**
     * @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object
     * @author fenris
     */
    function coin(str: string, args: {
        [id: string]: string;
    }, options?: {
        legacy?: boolean;
        open?: string;
        close?: string;
    }): string;
    /**
     * @author fenris
     * @deprecated use limit
     */
    function cut(str: string, length: int, delimiter?: string): string;
    /**
     */
    function limit(str: string, options?: {
        length?: int;
        indicator?: string;
    }): string;
    /**
     */
    function slice(str: string, size: int): Array<string>;
    /**
     */
    function capitalize(str: string): string;
}
/**
 * @deprecated
 */
declare namespace lib_string {
    const empty: typeof lib_plankton.string.empty;
    const generate: typeof lib_plankton.string.generate;
    const split: typeof lib_plankton.string.split;
    const explode: typeof lib_plankton.string.repeat;
    const repeat: typeof lib_plankton.string.repeat;
    const pad: typeof lib_plankton.string.pad;
    const contains: typeof lib_plankton.string.contains;
    const startsWith: typeof lib_plankton.string.startsWith;
    const endsWith: typeof lib_plankton.string.endsWith;
    const count_occourrences: typeof lib_plankton.string.count_occourrences;
    const coin: typeof lib_plankton.string.coin;
    const stance: typeof lib_plankton.string.coin;
    const cut: typeof lib_plankton.string.cut;
}
declare namespace lib_plankton.string {
    /**
     * an implementation of c sprintf
     * @param {string} string format string
     * @param {array} args arguments which should be filled into
     * @returns {string}
     */
    var sprintf: (input: string, args?: Array<any>, original?: any) => string;
    /**
     * an implementation of c printf
     * @param {string} string format string
     * @param {array} args arguments which should be filled into
     * @returns {string}
     */
    function printf(format: any, args: any): void;
}
declare var sprintf: (input: string, args?: Array<any>, original?: any) => string;
declare var printf: typeof lib_plankton.string.printf;
declare var eml_log: any;
declare var track_exports: any;
declare var make_logger: (prefix: any, current_loglevel: any) => (obj: any, lvl: any) => void;
declare namespace lib_plankton.database {
    /**
     */
    type type_query = {
        template: string;
        arguments: Record<string, any>;
    };
    /**
     */
    enum enum_type {
        boolean = "boolean",
        integer = "integer",
        string_short = "string_short",
        string_medium = "string_medium",
        string_long = "string_long",
        float = "float"
    }
    /**
     */
    type type_description_create_table = {
        name: string;
        key_field?: (null | {
            name: string;
            type?: enum_type;
            comment?: (null | string);
            auto_increment?: (null | boolean);
            description?: (null | string);
        });
        data_fields?: Array<{
            name: string;
            nullable?: boolean;
            type: enum_type;
            default?: any;
            description?: (null | string);
        }>;
        constraints?: Array<{
            kind: string;
            parameters?: Record<string, any>;
        }>;
        description?: (null | string);
    };
    /**
     */
    type type_description_insert = {
        table_name: string;
        values: Record<string, any>;
        returning?: (null | string);
    };
    /**
     */
    type type_description_update = {
        table_name: string;
        values: Record<string, any>;
        condition?: (null | string);
        arguments?: (null | Record<string, any>);
    };
    /**
     */
    type type_description_delete = {
        table_name: string;
        condition?: (null | string);
        arguments?: (null | Record<string, any>);
    };
    /**
     */
    type type_description_select = {
        source: string;
        fields?: (null | Array<string>);
        condition?: (null | string);
        group_by?: (null | string);
        having?: (null | string);
        order_by?: (null | string);
        limit?: (null | int);
        arguments?: (null | Record<string, any>);
    };
    /**
     * rows
     */
    type type_result_get = Array<Record<string, any>>;
    /**
     * auto insert id
     */
    type type_result_put = (null | int);
    /**
     * number of affected rows
     */
    type type_result_set = int;
    /**
     * @author fenris
     */
    type type_database = {
        wrap_name: ((name: string) => string);
        query_free_get: ((query: type_query) => Promise<type_result_get>);
        query_free_put: ((query: type_query) => Promise<type_result_put>);
        query_free_set: ((query: type_query) => Promise<type_result_set>);
        query_create_table: ((description_create_table: type_description_create_table) => Promise<void>);
        query_insert: ((description_insert: type_description_insert) => Promise<type_result_put>);
        query_update: ((description_update: type_description_update) => Promise<type_result_set>);
        query_delete: ((description_delete: type_description_delete) => Promise<type_result_set>);
        query_select: ((description_select: type_description_select) => Promise<type_result_get>);
    };
    /**
     */
    type interface_database = database.type_database;
}
declare namespace lib_plankton.storage {
    /**
     * implements the idea of a database, which houses datasets (type_value) and manages their access by ids or sth. similar (type_key)
     *
     * @author fenris
     */
    type type_store<type_key, type_value, type_setup_input, type_searchterm, type_preview> = {
        /**
         * shall prepare the storage instance for use
         *
         * @author fenris
         */
        setup(input: type_setup_input): Promise<void>;
        /**
         * shall insert a new dataset and return its automatically assign key
         *
         * @author fenris
         */
        create(value: type_value): Promise<type_key>;
        /**
         * shall modify an existing dataset
         *
         * @author fenris
         */
        update(key: type_key, value: type_value): Promise<void>;
        /**
         * shall remove an existing dataset
         *
         * @author fenris
         */
        delete(key: type_key): Promise<void>;
        /**
         * shall get an existing dataset by its key
         *
         * @author fenris
         */
        read(key: type_key): Promise<type_value>;
        /**
         * shall list keys and previews of existing datasets, which match a certain search term
         *
         * @author fenris
         */
        search(term?: (null | type_searchterm)): Promise<Array<{
            key: type_key;
            preview: type_preview;
        }>>;
    };
    /**
     * for class wrappers
     */
    type interface_store<type_key, type_value, type_setup_input, type_searchterm, type_preview> = type_store<type_key, type_value, type_setup_input, type_searchterm, type_preview>;
}
declare namespace lib_plankton.storage {
    /**
     * implements the idea of a storage without managed keys
     *
     * @author fenris
     */
    type type_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview> = {
        /**
         * shall prepare the storage instance for use
         *
         * @author fenris
         */
        setup(input: type_setup_input): Promise<void>;
        /**
         * shall remove all items
         */
        clear(): Promise<void>;
        /**
         * shall insert a new or modify an existing dataset and return whether it is new
         *
         * @author fenris
         */
        write(key: type_key, value: type_value): Promise<boolean>;
        /**
         * shall remove an existing dataset
         *
         * @author fenris
         */
        delete(key: type_key): Promise<void>;
        /**
         * shall get an existing dataset by its key
         *
         * @author fenris
         */
        read(key: type_key): Promise<type_value>;
        /**
         * shall list keys and previews of existing datasets, which match a certain search term
         *
         * @author fenris
         */
        search(term?: (null | type_searchterm)): Promise<Array<{
            key: type_key;
            preview: type_preview;
        }>>;
    };
    /**
     * for class wrappers
     */
    type interface_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview> = type_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview>;
}
declare namespace lib_plankton.storage.memory {
    /**
     * @author fenris
     */
    type type_subject<type_value> = {
        data: Record<string, type_value>;
    };
    /**
     */
    type type_parameters<type_value> = {};
    /**
     * @author fenris
     */
    function make<type_value>(parameters: type_parameters<type_value>): type_subject<type_value>;
    /**
     * @author fenris
     */
    function clear<type_value>(subject: type_subject<type_value>): void;
    /**
     * @author fenris
     */
    function write<type_value>(subject: type_subject<type_value>, key: string, value: type_value): boolean;
    /**
     * @author fenris
     */
    function delete_<type_value>(subject: type_subject<type_value>, key: string): void;
    /**
     * @author fenris
     */
    function read<type_value>(subject: type_subject<type_value>, key: string): type_value;
    /**
     * @author fenris
     */
    function list<type_value>(subject: type_subject<type_value>): Array<string>;
    /**
     * @author fenris
     */
    function search<type_value>(subject: type_subject<type_value>, term: (null | string)): Array<{
        key: string;
        preview: string;
    }>;
    /**
     * @author fenris
     */
    function implementation_chest<type_value>(parameters: type_parameters<type_value>): type_chest<string, type_value, void, string, string>;
}
declare namespace lib_plankton.storage.memory {
    /**
     * @author fenris
     */
    class class_chest<type_item> implements type_chest<string, type_item, void, string, string> {
        private subject;
        constructor(parameters: type_parameters<type_item>);
        setup(input: any): Promise<void>;
        clear(): Promise<void>;
        write(key: any, value: any): Promise<boolean>;
        delete(key: any): Promise<void>;
        read(key: any): Promise<Awaited<type_item>>;
        search(term: any): Promise<{
            key: string;
            preview: string;
        }[]>;
    }
}
declare namespace lib_plankton.storage.localstorage {
    /**
     * @author fenris
     */
    type type_subject = {
        corner: string;
    };
    /**
     * @author fenris
     */
    type type_parameters = {
        corner?: string;
    };
    /**
     * @author fenris
     */
    function make(parameters: type_parameters): type_subject;
    /**
     * @author fenris
     */
    function clear(subject: type_subject): void;
    /**
     * @author fenris
     */
    function write(subject: type_subject, key: string, item: string): boolean;
    /**
     * @author fenris
     */
    function delete_(subject: type_subject, key: string): void;
    /**
     * @author fenris
     */
    function read(subject: type_subject, key: string): string;
    /**
     * @author fenris
     */
    function list(subject: type_subject): Array<string>;
    /**
     */
    function implementation_chest(parameters: type_parameters): type_chest<string, string, void, string, string>;
}
declare namespace lib_plankton.storage.localstorage {
    /**
     * uses the browsers localstorage as chest
     *
     * @author fenris
     */
    class class_chest implements type_chest<string, string, string, string, any> {
        private subject;
        constructor(parameters: type_parameters);
        setup(input: any): Promise<void>;
        clear(): Promise<void>;
        write(key: any, value: any): Promise<boolean>;
        delete(key: any): Promise<void>;
        read(key: any): Promise<string>;
        search(term: any): Promise<{
            key: string;
            preview: string;
        }[]>;
    }
}
declare namespace lib_plankton.shape {
    /**
     * @todo
     */
    type type_jsonschema = any;
    /**
     * @todo
     */
    type type_oas_schema = any;
    /**
     * @author fenris
     */
    type type_inspection = {
        flaws: Array<string>;
        sub: Array<{
            position: string;
            inspection: type_inspection;
        }>;
    };
    /**
     * @author fenris
     */
    function inspection_create(): type_inspection;
    /**
     * @author fenris
     */
    function inspection_add(main: type_inspection, flaw: string): void;
    /**
     * @author fenris
     */
    function inspection_extend(main: type_inspection, prefix: string, sub: type_inspection): void;
    /**
     */
    type type_shape = {
        kind: string;
        parameters: Record<string, any>;
    };
    /**
     * @author fenris
     */
    type type_logic = {
        inspect: ((sub_inspect: ((shape: type_shape, value: any) => type_inspection), value: any) => type_inspection);
        show: ((sub_show: ((shape: type_shape) => string)) => string);
        to_typescript_type: ((sub_to_typescript_type: ((shape: type_shape) => string)) => string);
        to_jsonschema: ((sub_to_json_schema: ((shape: type_shape) => type_jsonschema)) => type_jsonschema);
        to_oas_schema: ((sub_to_oas_schema: ((shape: type_shape) => type_oas_schema)) => type_oas_schema);
        example: ((sub_example: ((shape: type_shape) => any)) => any);
    };
    /**
     */
    function inspect(shape: type_shape, value: any): type_inspection;
    /**
     */
    function inspect_flat(shape: type_shape, value: any): Array<string>;
    /**
     */
    function show(shape: type_shape): string;
    /**
     */
    function to_typescript_type(shape: type_shape): string;
    /**
     */
    function to_jsonschema(shape: type_shape): type_jsonschema;
    /**
     */
    function to_oas_schema(shape: type_shape): type_oas_schema;
    /**
     */
    function example(shape: type_shape): any;
    /**
     */
    function register<type_parameters, type_subject>(name: string, construct: ((parameters: type_parameters) => type_subject), logic: ((subject: type_subject) => type_logic)): void;
}
declare namespace lib_plankton.shape.any {
    /**
     */
    type type_subject = {};
    /**
     */
    export function make(options?: {}): type_subject;
    export {};
}
declare namespace lib_plankton.shape.null_ {
    /**
     */
    type type_subject = {};
    /**
     */
    export function make(options?: {}): type_subject;
    export {};
}
declare namespace lib_plankton.shape.boolean {
    /**
     */
    type type_subject = {
        soft: boolean;
        defaultvalue: lib_plankton.pod.type_pod<any>;
        description: lib_plankton.pod.type_pod<string>;
    };
    /**
     */
    export function make(options?: {
        soft?: boolean;
        defaultvalue?: (null | boolean);
        description?: string;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.shape.integer {
    /**
     */
    type type_subject = {
        soft: boolean;
        defaultvalue: lib_plankton.pod.type_pod<any>;
        description: lib_plankton.pod.type_pod<string>;
        minimum: lib_plankton.pod.type_pod<int>;
        maximum: lib_plankton.pod.type_pod<int>;
    };
    /**
     */
    export function make(options?: {
        soft?: boolean;
        defaultvalue?: (null | int);
        description?: string;
        minimum?: int;
        maximum?: int;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.shape.float {
    /**
     */
    type type_subject = {
        soft: boolean;
        defaultvalue: lib_plankton.pod.type_pod<any>;
        description: lib_plankton.pod.type_pod<string>;
        minimum: lib_plankton.pod.type_pod<float>;
        maximum: lib_plankton.pod.type_pod<float>;
    };
    /**
     */
    export function make(options?: {
        soft?: boolean;
        defaultvalue?: (null | float);
        description?: string;
        minimum?: float;
        maximum?: float;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.shape.string {
    /**
     */
    type type_subject = {
        soft: boolean;
        defaultvalue: lib_plankton.pod.type_pod<any>;
        description: lib_plankton.pod.type_pod<string>;
        pattern: lib_plankton.pod.type_pod<string>;
        min_length: lib_plankton.pod.type_pod<int>;
        max_length: lib_plankton.pod.type_pod<int>;
    };
    /**
     */
    export function make(options?: {
        soft?: boolean;
        defaultvalue?: (null | int);
        description?: string;
        pattern?: string;
        min_length?: int;
        max_length?: int;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.shape.email {
    /**
     */
    type type_subject = {
        core: type_shape;
    };
    /**
     */
    export function make(options?: {
        soft?: boolean;
        defaultvalue?: (null | int);
        description?: string;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.shape.list_ {
    /**
     */
    type type_subject = {
        shape_element: type_shape;
        soft: boolean;
        defaultvalue: lib_plankton.pod.type_pod<any>;
        description: lib_plankton.pod.type_pod<string>;
    };
    /**
     */
    export function make(shape_element: type_shape, options?: {
        soft?: boolean;
        defaultvalue?: any;
        description?: string;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.shape.map {
    /**
     */
    type type_subject = {
        shape_key: type_shape;
        shape_value: type_shape;
        soft: boolean;
        defaultvalue: lib_plankton.pod.type_pod<any>;
        description: lib_plankton.pod.type_pod<string>;
    };
    /**
     */
    export function make(shape_key: type_shape, shape_value: type_shape, options?: {
        soft?: boolean;
        defaultvalue?: any;
        description?: string;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.shape.record {
    /**
     */
    type type_field = {
        name: string;
        shape: type_shape;
        required: boolean;
    };
    /**
     */
    type type_subject = {
        fields: Array<type_field>;
        soft: boolean;
        defaultvalue: lib_plankton.pod.type_pod<any>;
        description: lib_plankton.pod.type_pod<string>;
    };
    /**
     */
    export function make(fields_raw: Array<{
        name: string;
        shape: type_shape;
        required?: boolean;
    }>, options?: {
        soft?: boolean;
        defaultvalue?: any;
        description?: string;
    }): type_subject;
    export {};
}
declare namespace lib_plankton.www_form {
    /**
     */
    type type_source = Record<string, string>;
    /**
     */
    type type_target = string;
    /**
     * @author fenris
     */
    function encode(source: type_source): type_target;
    /**
     * @author fenris
     */
    function decode(target: type_target): type_source;
}
declare namespace lib_plankton.www_form {
    /**
     * @author fenris
     */
    class class_www_form implements lib_plankton.code.interface_code<type_source, type_target> {
        /**
         * @author fenris
         */
        constructor();
        /**
         * @implementation
         * @author fenris
         */
        encode(source: type_source): type_target;
        /**
         * @implementation
         * @author fenris
         */
        decode(target: type_target): type_source;
    }
}
declare namespace lib_plankton.url {
    /**
     * @author fenris
     */
    type type_url = {
        scheme: (null | string);
        host: (null | string);
        username: (null | string);
        password: (null | string);
        port: (null | int);
        path: (null | string);
        query: (null | string);
        hash: (null | string);
    };
}
declare namespace lib_plankton.url {
    /**
     * @author fenris
     */
    function encode(url: type_url): string;
    /**
     * @author fenris
     * @todo arguments
     */
    function decode(url_raw: string): type_url;
    /**
     * @author fenris
     */
    function implementation_code(): lib_plankton.code.type_code<type_url, string>;
}
declare namespace lib_plankton.url {
    /**
     * @author fenris
     */
    class class_url implements lib_plankton.code.interface_code<type_url, string> {
        /**
         * @author fenris
         */
        constructor();
        /**
         * @implementation
         * @author fenris
         */
        encode(x: any): string;
        /**
         * @implementation
         * @author fenris
         */
        decode(x: string): any;
    }
}
declare namespace lib_plankton.random {
    /**
     * @author fenris
     */
    type type_state = {
        builtin: boolean;
        seed?: int;
    };
    /**
     * @author fenris
     */
    function state_push(state: type_state): void;
    /**
     * @author fenris
     */
    function state_pop(): type_state;
    /**
     * returns a random floating point number in the interval [0,1[
     *
     * @author fenris
     */
    function generate_unit(): float;
    /**
     * returns a random boolean value
     *
     * @param {float} [probability] the probability for the return-value "true"; default: 0.5
     * @author fenris
     */
    function generate_boolean(options?: {
        probability?: float;
    }): boolean;
    /**
     * returns a random integer number in the interval [a,b]
     *
     * @param {int} [minimum] the left side of the halfopen interval (i.e. the smallest included value in the range)
     * @param {int} [minimum] the right side of the halfopen interval (i.e. the smallest excluded value in the range)
     * @author fenris
     */
    function generate_integer(options?: {
        minimum?: int;
        maximum?: int;
    }): int;
    var generate_int: typeof generate_integer;
    /**
     * returns a random floating point number in the given interval
     *
     * @author fenris
     */
    function generate_float(options?: {
        minimum?: int;
        maximum?: int;
    }): float;
    /**
     * returns a random date
     *
     * @author fenris
     */
    function generate_date(options?: {
        minimum?: Date;
        maximum?: Date;
    }): Date;
    /**
     * @author fenris
     */
    function generate_hexdigit(): string;
    /**
     * generates a random string with an optional prefix
     *
     * @author fenris
     */
    function generate_string(options?: {
        length?: int;
    }): string;
    /**
     * chooses a value randomly from a list of values with weights (a higher weight means a higher probability to be chosen)
     *
     * @author fenris
     */
    function choose_weighted<type_value>(sets: Array<{
        weight: float;
        value: type_value;
    }>): type_value;
    /**
     * chooses a value randomly from a list of values with equal probabilities
     *
     * @author fenris
     */
    function choose_uniformly<type_value>(values: Array<type_value>): type_value;
    /**
     * @author fenris
     */
    function shuffle<type_element>(list: Array<type_element>): Array<type_element>;
    /**
     * @author fenris
     */
    function generate_vowel(): string;
    /**
     * @author fenris
     */
    function generate_halfvowel(): string;
    /**
     * @author fenris
     */
    function generate_consonant(): string;
    /**
     * @author fenris
     */
    function generate_letter(): string;
    /**
     * @author fenris
     */
    function generate_syllable(): string;
    /**
     * @author fenris
     */
    function generate_word(options?: {
        syllable_count_minimum?: int;
        syllable_count_maximum?: int;
    }): string;
    /**
     * @author fenris
     */
    function generate_text(options?: {
        word_count?: int;
    }): string;
    /**
     * @author fenris
     */
    function generate_city(): string;
    /**
     * @author fenris
     */
    function generate_street(): string;
    /**
     * @author fenris
     */
    function generate_guid(options?: {
        with_braces?: boolean;
    }): string;
    /**
     * @author fenris
     */
    function generate_url(): string;
    /**
     * @author fenris
     */
    function generate_email_address(): string;
    /**
     * @author fenris
     */
    function generate_telephone_number(): string;
    /**
     * @author fenris
     */
    function generate_time(): any;
    /**
     * @author fenris
     * @deprecated
     * @todo remove
     */
    function generate_for_shape(shape: any): any;
    /**
     * @author fenris
     */
}
declare namespace lib_plankton.map {
    /**
     */
    type type_pair<type_key, type_value> = {
        key: type_key;
        value: type_value;
    };
    /**
     * @author fenris
     */
    type type_map<type_key, type_value> = {
        size: (() => int);
        has: ((key: type_key) => boolean);
        get: ((key: type_key, fallback?: lib_plankton.pod.type_pod<type_value>) => type_value);
        set: ((key: type_key, value: type_value) => void);
        delete: ((key: type_key) => void);
        iterate: ((procedure: ((value: type_value, key?: type_key) => void)) => void);
    };
}
declare namespace lib_plankton.map {
    /**
     */
    function clear<type_key, type_value>(map: type_map<type_key, type_value>): void;
    /**
     */
    function keys<type_key, type_value>(map: type_map<type_key, type_value>): Array<type_key>;
    /**
     */
    function values<type_key, type_value>(map: type_map<type_key, type_value>): Array<type_value>;
    /**
     */
    function dump<type_key, type_value>(map: type_map<type_key, type_value>): Array<type_pair<type_key, type_value>>;
    /**
     */
    function show<type_key, type_value>(map: type_map<type_key, type_value>, options?: {
        show_key?: ((key: type_key) => string);
        show_value?: ((value: type_value) => string);
    }): string;
}
declare namespace lib_plankton.map.simplemap {
    /**
     */
    type type_subject<type_value> = {
        data: Record<string, type_value>;
    };
    /**
     */
    function make<type_value>(options?: {
        data?: Record<string, type_value>;
    }): type_subject<type_value>;
    /**
     */
    function size<type_value>(subject: type_subject<type_value>): int;
    /**
     */
    function has<type_value>(subject: type_subject<type_value>, key: string): boolean;
    /**
     */
    function get_safe<type_value>(subject: type_subject<type_value>, key: string): lib_plankton.pod.type_pod<type_value>;
    /**
     */
    function get<type_value>(subject: type_subject<type_value>, key: string, fallback?: lib_plankton.pod.type_pod<type_value>): type_value;
    /**
     */
    function set<type_value>(subject: type_subject<type_value>, key: string, value: type_value): void;
    /**
     */
    function delete_<type_value>(subject: type_subject<type_value>, key: string): void;
    /**
     */
    function iterate<type_value>(subject: type_subject<type_value>, procedure: ((value?: type_value, key?: string) => void)): void;
    /**
     */
    function implementation_map<type_value>(subject: type_subject<type_value>): type_map<string, type_value>;
}
declare namespace lib_plankton.map.hashmap {
    /**
     * we base the hashmap on a simplemap, whos keys are the hashes and whos values are the key/value-pairs
     */
    type type_subject<type_key, type_value> = {
        hashing: ((key: type_key) => string);
        core: lib_plankton.map.simplemap.type_subject<type_pair<type_key, type_value>>;
    };
    /**
     */
    function make<type_key, type_value>(hashing: ((key: type_key) => string), options?: {
        pairs?: Array<type_pair<type_key, type_value>>;
    }): type_subject<type_key, type_value>;
    /**
     */
    function size<type_key, type_value>(subject: type_subject<type_key, type_value>): int;
    /**
     */
    function has<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): boolean;
    /**
     */
    function get<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, fallback?: lib_plankton.pod.type_pod<type_value>): type_value;
    /**
     */
    function set<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, value: type_value): void;
    /**
     */
    function delete_<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): void;
    /**
     */
    function iterate<type_key, type_value>(subject: type_subject<type_key, type_value>, procedure: ((value?: type_value, key?: type_key) => void)): void;
    /**
     */
    function implementation_map<type_key, type_value>(subject: type_subject<type_key, type_value>): type_map<type_key, type_value>;
}
declare namespace lib_plankton.map.collatemap {
    /**
     */
    type type_collation<type_key> = ((key1: type_key, key2: type_key) => boolean);
    /**
     */
    export type type_subject<type_key, type_value> = {
        collation: type_collation<type_key>;
        pairs: Array<type_pair<type_key, type_value>>;
    };
    /**
     */
    export function make<type_key, type_value>(collation: type_collation<type_key>, options?: {
        pairs?: Array<type_pair<type_key, type_value>>;
    }): type_subject<type_key, type_value>;
    /**
     */
    export function size<type_key, type_value>(subject: type_subject<type_key, type_value>): int;
    /**
     */
    export function has<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): boolean;
    /**
     * @todo use .find
     */
    export function get<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, fallback?: lib_plankton.pod.type_pod<type_value>): type_value;
    /**
     */
    export function set<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, value: type_value): void;
    /**
     */
    export function delete_<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): void;
    /**
     */
    export function iterate<type_key, type_value>(subject: type_subject<type_key, type_value>, function_: ((value?: type_value, key?: type_key) => void)): void;
    /**
     */
    export function implementation_map<type_key, type_value>(subject: type_subject<type_key, type_value>): type_map<type_key, type_value>;
    export {};
}
declare namespace lib_plankton.set {
    /**
     */
    type type_set<type_element> = {
        size: (() => int);
        has: ((element: type_element) => boolean);
        add: ((element: type_element) => void);
        remove: ((element: type_element) => void);
        iterate: ((procedure: ((element: type_element) => void)) => void);
    };
}
declare namespace lib_plankton.set {
    /**
     */
    function clear<type_element>(set: type_set<type_element>): void;
    /**
     */
    function dump<type_element>(set: type_set<type_element>): Array<type_element>;
    /**
     */
    function show<type_element>(set: type_set<type_element>, { "show_element": show_element, }?: {
        show_element?: ((element: type_element) => string);
    }): string;
    /**
     */
    function map<type_element_from, type_element_to>(construct: (() => type_set<type_element_to>), set: type_set<type_element_from>, transformator: ((element: type_element_from) => type_element_to)): type_set<type_element_to>;
    /**
     */
    function filter<type_element>(construct: (() => type_set<type_element>), set: type_set<type_element>, predicate: ((element: type_element) => boolean)): type_set<type_element>;
    /**
     */
    function subset<type_element>(set1: type_set<type_element>, set2: type_set<type_element>): boolean;
    /**
     */
    function superset<type_element>(set1: type_set<type_element>, set2: type_set<type_element>): boolean;
    /**
     */
    function equal<type_element>(set1: type_set<type_element>, set2: type_set<type_element>): boolean;
    /**
     */
    function empty<type_element>(set: type_set<type_element>): boolean;
    /**
     */
    function union<type_element>(construct: (() => type_set<type_element>), set1: type_set<type_element>, set2: type_set<type_element>): type_set<type_element>;
    /**
     */
    function intersection<type_element>(construct: (() => type_set<type_element>), set1: type_set<type_element>, set2: type_set<type_element>): type_set<type_element>;
    /**
     */
    function difference<type_element>(construct: (() => type_set<type_element>), set1: type_set<type_element>, set2: type_set<type_element>): type_set<type_element>;
    /**
     */
    function symmetric_difference<type_element>(construct: (() => type_set<type_element>), set1: type_set<type_element>, set2: type_set<type_element>): type_set<type_element>;
}
declare namespace lib_plankton.set.hashset {
    /**
     */
    type type_hashing<type_element> = ((element: type_element) => string);
    /**
     */
    export type type_subject<type_element> = {
        core: lib_plankton.map.hashmap.type_subject<type_element, null>;
    };
    /**
     */
    export function make<type_element>(hashing: type_hashing<type_element>, options?: {
        elements?: Array<type_element>;
    }): type_subject<type_element>;
    /**
     */
    export function size<type_element>(subject: type_subject<type_element>): int;
    /**
     */
    export function has<type_element>(subject: type_subject<type_element>, element: type_element): boolean;
    /**
     */
    export function add<type_element>(subject: type_subject<type_element>, element: type_element): void;
    /**
     */
    export function remove<type_element>(subject: type_subject<type_element>, element: type_element): void;
    /**
     */
    export function iterate<type_element>(subject: type_subject<type_element>, procedure: ((element: type_element) => void)): void;
    /**
     */
    export function implementation_set<type_element>(subject: type_subject<type_element>): type_set<type_element>;
    export {};
}
declare namespace lib_plankton.set.collateset {
    /**
     */
    type type_collation<type_element> = ((x: type_element, y: type_element) => boolean);
    /**
     */
    export type type_subject<type_element> = {
        core: lib_plankton.map.collatemap.type_subject<type_element, null>;
    };
    /**
     */
    export function make<type_element>(collation: type_collation<type_element>, options?: {
        elements?: Array<type_element>;
    }): type_subject<type_element>;
    /**
     */
    export function size<type_element>(subject: type_subject<type_element>): int;
    /**
     */
    export function has<type_element>(subject: type_subject<type_element>, element: type_element): boolean;
    /**
     */
    export function add<type_element>(subject: type_subject<type_element>, element: type_element): void;
    /**
     */
    export function remove<type_element>(subject: type_subject<type_element>, element: type_element): void;
    /**
     */
    export function iterate<type_element>(subject: type_subject<type_element>, procedure: ((element: type_element) => void)): void;
    /**
     */
    export function implementation_set<type_element>(subject: type_subject<type_element>): type_set<type_element>;
    export {};
}
declare namespace lib_plankton.cache {
    /**
     */
    type type_result<type_value> = {
        retrieved: boolean;
        value: type_value;
    };
    /**
     */
    type type_entry<type_value> = {
        value: type_value;
        expiry: (null | float);
    };
    /**
     */
    type type_subject<type_value> = lib_plankton.storage.type_chest<string, type_entry<type_value>, void, any, any>;
}
declare namespace lib_plankton.cache {
    /**
     */
    function make<type_value>({ "chest": chest, }?: {
        chest?: lib_plankton.storage.type_chest<string, type_entry<type_value>, void, any, any>;
    }): type_subject<type_value>;
    /**
     */
    function init<type_value>(subject: type_subject<type_value>): Promise<void>;
    /**
     */
    function clear<type_value>(subject: type_subject<type_value>): Promise<void>;
    /**
     */
    function invalidate<type_value>(subject: type_subject<type_value>, key: string): Promise<void>;
    /**
     */
    function query<type_value>(subject: type_subject<type_value>, key: string, lifetime: (null | float), retrieve: (() => Promise<type_value>)): Promise<type_result<type_value>>;
    /**
     * syntactic sugar: if the information, whether the value was retrieved, is irrelevant
     */
    function get<type_value>(subject: type_subject<type_value>, key: string, lifetime: (null | float), retrieve: (() => Promise<type_value>)): Promise<type_value>;
    /**
     */
    function get_complex<type_input, type_value>(cache: type_subject<type_value>, group: string, input: type_input, lifetime: (null | float), retrieve: ((input: type_input) => Promise<type_value>), { "encode_input": encode_input, }?: {
        encode_input?: ((input: type_input) => string);
    }): Promise<type_value>;
}
declare namespace lib_plankton.complex {
    /**
     * @author fenris
     */
    type type_complex = {
        rea: float;
        ima: float;
    };
    /**
     * erstellt eine komplexe Zahl anhand ihrer kartesianischen Koordinaten
     *
     * @author fenris
     */
    function make_cartesian(rea_: float, ima_: float): type_complex;
    /**
     * erstellt eine komplexe Zahl anhand ihrer Polar-Koordinaten
     *
     * @author fenris
     */
    function make_polar(abs: float, arg: float): type_complex;
    /**
     * alias zu "make_cartesian"
     *
     * @author fenris
     */
    function make(rea_: float, ima_: float): type_complex;
    /**
     * erstellt die komplexe Null
     *
     * @author fenris
     */
    function nul(): type_complex;
    /**
     * erstellt die komplexe Eins
     *
     * @author fenris
     */
    function one(): type_complex;
    /**
     * gibt den Real-Teil einer komplexen Zahl zurück
     *
     * @author fenris
     */
    function rea(x: type_complex): float;
    /**
     * gibt den Imaginär-Teil einer komplexen Zahl zurück
     *
     * @author fenris
     */
    function ima(x: type_complex): float;
    /**
     * gibt die konjugierte komplexe Zahl zurück
     *
     * @author fenris
     */
    function con(x: type_complex): type_complex;
    /**
     * gibt den Betrag einer komplexen Zahl zurück
     *
     * @author fenris
     */
    function abs(x: type_complex): float;
    /**
     * gibt das Argument einer komplexen Zahl zurück (auf dem Hauptzweig des komplexen Logarithmus)
     *
     * @author fenris
     */
    function arg(x: type_complex): float;
    /**
     * gibt eine skalierte komplexe Zahl zurück (das Produkt mit einer reellen Zahl)
     *
     * @author fenris
     */
    function scl(x: type_complex, s: float): type_complex;
    /**
     * errechnet die Summe zweier komplexer Zahl
     *
     * @author fenris
     */
    function add(x: type_complex, y: type_complex): type_complex;
    /**
     * gibt die additiv inverse, also negierte komplexe Zahl zurück
     *
     * @author fenris
     */
    function neg(x: type_complex): type_complex;
    /**
     * ermittelt die Differenz zweier komplexer Zahlen
     *
     * @author fenris
     */
    function sub(x: type_complex, y: type_complex): type_complex;
    /**
     * ermittelt das Produkt zweier komplexer Zahlen
     *
     * @author fenris
     */
    function mul(x: type_complex, y: type_complex): type_complex;
    /**
     * ermittelt die multiplikativ inverse komplexe Zahl, also den Kehrwert
     *
     * @author fenris
     */
    function inv(x: type_complex): type_complex;
    /**
     * ermittelt den Quotienten zweier komplexer Zahlen
     *
     * @author fenris
     */
    function div(x: type_complex, y: type_complex): type_complex;
    /**
     * ermittelt die natürliche Potenz einer komplexen Zahl
     *
     * @author fenris
     */
    function npow(x: type_complex, n: int): type_complex;
    /**
     * ermittelt den Wert der natürlichen Exponential-Funktion
     *
     * @author fenris
     */
    function exp(x: type_complex): type_complex;
    /**
     * ermittelt die Potenz zweier komplexer Zahlen
     *
     * @author fenris
     * @todo Probleme der komplexen Exponentiation berücksichtigen
     */
    function pow(x: type_complex, y: type_complex): type_complex;
    /**
     * gibt die n-ten komplexen Einheits-Wurzeln zurück ({x ∈ C | x^n = 1})
     *
     * @author fenris
     */
    function unitroots(n: int): Array<type_complex>;
    /**
     * {x ∈ C | x^n = y}
     *
     * @author fenris
     */
    function normroots(n: int, y: type_complex): Array<type_complex>;
    /**
     * ermittelt ob zwei komplexe Zahlen gleich sind
     *
     * @author fenris
     */
    function equ(x: type_complex, y: type_complex, threshold?: float): boolean;
    /**
     * gibt eine textuelle Repräsentation einer komplexen Zahl zurück
     *
     * @author fenris
     */
    function str(x: type_complex): string;
}
declare namespace lib_plankton.complex {
    /**
     * @author fenris
     */
    class class_complex {
        /**
         * @author fenris
         */
        private subject;
        /**
         * @author fenris
         */
        private constructor();
        /**
         * @author fenris
         */
        private static _cram;
        /**
         * @author fenris
         */
        private static _tear;
        /**
         * @author fenris
         */
        static make_cartesian(rea: float, ima: float): class_complex;
        /**
         * @author fenris
         */
        static make_polar(abs: float, arg: float): class_complex;
        /**
         * @author fenris
         */
        static make(rea: float, ima: float): class_complex;
        /**
         * @author fenris
         */
        static nul(): class_complex;
        /**
         * @author fenris
         */
        static one(): class_complex;
        /**
         * @author fenris
         */
        con(): class_complex;
        /**
         * @author fenris
         */
        abs(): float;
        /**
         * @author fenris
         */
        arg(): float;
        /**
         * @author fenris
         */
        scl(s: float): class_complex;
        /**
         * @author fenris
         */
        add(other: class_complex): class_complex;
        /**
         * @author fenris
         */
        neg(): class_complex;
        /**
         * @author fenris
         */
        sub(other: class_complex): class_complex;
        /**
         * @author fenris
         */
        mul(other: class_complex): class_complex;
        /**
         * @author fenris
         */
        inv(): class_complex;
        /**
         * @author fenris
         */
        div(other: class_complex): class_complex;
        /**
         * @author fenris
         */
        exp(): class_complex;
        /**
         * @author fenris
         */
        pow(other: class_complex): class_complex;
        /**
         * @author fenris
         */
        equ(other: class_complex): boolean;
        /**
         * @author fenris
         */
        str(): string;
        /**
         * @author fenris
         */
        toString(): string;
    }
}
declare namespace lib_plankton.math {
    /**
     * @desc golden ratio (e.g. for generating colors)
     * @author fenris
     */
    const phi: float;
    /**
     * @author fenris
     */
    const e: float;
    /**
     * @author fenris
     */
    const pi: float;
    /**
     * @author fenris
     */
    const tau: float;
}
declare namespace lib_plankton.math {
    /**
     * @author fenris
     */
    function clamp(x: number, a?: number, b?: number): number;
    /**
     * @desc the mathematical sign-function
     * @return {int} an element of {-1,0,+1}
     * @author fenris
     */
    function sgn(x: number): int;
    /**
     * @desc integer division
     * @author fenris
     */
    function div(x: float, y: float): float;
    /**
     * @desc real modulo operator
     * @author fenris
     */
    function mod(x: float, y: float): float;
    /**
     * @desc computes "x^y mod z" via square-and-multiply
     * @param {int} base ("x")
     * @param {int} exponent ("y")
     * @param {int} modulus ("z")
     * @return {int}
     * @author fenris
     * @todo handle invalid cases (e.g. "z < 1")
     * @todo implement iteratively
     */
    function modpow(base: int, exponent: int, modulus: int): int;
    /**
     * @desc determines if two integers are coprime, i.e. that they don't have a common divisor greater than 1
     * @author fenris
     * @todo write function "gcdx" and base on it
     */
    function coprime(x: int, y: int): boolean;
    /**
     * @desc extended euclidean algorithm for computing multiplicative inverse elements
     * @param {int} modulus
     * @param {int} element
     * @author fenris
     * @todo write function "gcdx" and base on it
     * @todo handle more invalid cases
     */
    function inv(modulus: int, element: int, positive?: boolean): int;
    /**
     * @author fenris
     */
    function interpolate_linear(x: number, y: number, t?: number): number;
    /**
     * @desc kind of the inverse of linear interpolation; i.e. to find the coefficient "t" for given values x, y and
     *     their presumed interpolation v
     * @author fenris
     */
    function appoint_linear(x: number, y: number, v: number): number;
    /**
     * continued fraction decomposition
     */
    function cfd(x: float, n?: int): Array<int>;
}
declare namespace lib_plankton.math {
    /**
     * @author fenris
     */
    type type_relationparameters<type_value> = {
        symbol?: string;
        name?: string;
        predicate?: (value: type_value, reference: type_value) => boolean;
    };
    /**
     * @author fenris
     */
    class class_relation<type_value> implements interface_showable, interface_hashable, interface_collatable<class_relation<type_value>> {
        /**
         * @author fenris
         */
        protected id: string;
        /**
         * @author fenris
         */
        protected symbol: string;
        /**
         * @author fenris
         */
        protected name: string;
        /**
         * @author fenris
         */
        protected predicate: (value: type_value, reference: type_value) => boolean;
        /**
         * @author fenris
         */
        check(value: type_value, reference: type_value): boolean;
        /**
         * @author fenris
         */
        constructor(id: string, { "symbol": symbol, "name": name, "predicate": predicate, }: type_relationparameters<type_value>);
        /**
         * @author fenris
         */
        id_get(): string;
        /**
         * @author fenris
         */
        symbol_get(): string;
        /**
         * @author fenris
         */
        name_get(): string;
        /**
         * @desc [accessor] [implementation]
         * @author fenris
         */
        _show(): string;
        /**
         * @desc [accessor] [implementation]
         * @author fenris
         */
        _hash(): string;
        /**
         * @desc [accessor] [implementation]
         * @author fenris
         */
        _collate(relation: class_relation<type_value>): boolean;
        /**
         * @author fenris
         */
        toString(): string;
        /**
         * @author fenris
         */
        protected static pool<type_value>(): {
            [id: string]: type_relationparameters<type_value>;
        };
        /**
         * @author fenris
         */
        static get<type_value>(id: string): class_relation<type_value>;
        /**
         * @author fenris
         */
        static available(): Array<string>;
    }
    /**
     * @author fenris
     */
    class class_filtrationitem<type_value> implements interface_showable {
        /**
         * @author fenris
         */
        protected extract: (dataset: Object) => type_value;
        /**
         * @author fenris
         */
        protected relation: class_relation<type_value>;
        /**
         * @author fenris
         */
        protected reference: type_value;
        /**
         * @author fenris
         */
        constructor({ "extract": extract, "relation": relation, "reference": reference, }: {
            extract: (dataset: Object) => type_value;
            relation: class_relation<type_value>;
            reference: type_value;
        });
        /**
         * @author fenris
         */
        check(dataset: Object): boolean;
        /**
         * @desc [implementation]
         * @author fenris
         */
        _show(): string;
        /**
         * @author fenris
         */
        toString(): string;
    }
    /**
     * @desc disjunctive normal form
     * @author fenris
     */
    class class_filtration implements interface_showable {
        /**
         * @author fenris
         */
        protected clauses: Array<Array<class_filtrationitem<any>>>;
        /**
         * @author fenris
         */
        constructor(clauses: Array<Array<class_filtrationitem<any>>>);
        /**
         * @author fenris
         */
        check(dataset: Object): boolean;
        /**
         * @author fenris
         */
        use(datasets: Array<Object>): Array<Object>;
        /**
         * @desc [implementation]
         * @author fenris
         */
        _show(): string;
        /**
         * @author fenris
         */
        toString(): string;
    }
    /**
     * @author fenris
     * @deprecated
     */
    function comparator_to_relation<type_value>(comparator: (x: type_value, y: type_value) => int): (x: type_value, y: type_value) => boolean;
    /**
     * @author fenris
     * @deprecated
     */
    function relation_to_comparator<type_value>(relation: (x: type_value, y: type_value) => boolean): (x: type_value, y: type_value) => int;
}
declare module lib_calculus {
    /**
     * @class Calculus
     * @desc Ensure precision of mathematical operations
     */
    class Calculus {
        /** @desc only for typescript
         */
        private NORM;
        /**
         * @constructor
         * @þaram {number} norm
         */
        constructor(norm?: number);
        /**
         * normalize
         * @param {number} value
         * @return {number}
         */
        normalize(value: number): number;
        /**
         * denormalize
         * @param {number} value
         * @return {number}
         */
        denormalize(value: number): number;
    }
}
declare namespace lib_plankton.math {
    /**
     * {x ∈ C | 0 = ax³ + bx² + cx + d}
     *
     * @author fenris
     */
    function cubic_solve(a: lib_plankton.complex.type_complex, b: lib_plankton.complex.type_complex, c: lib_plankton.complex.type_complex, d: lib_plankton.complex.type_complex): Array<lib_plankton.complex.type_complex>;
    /**
     * {x ∈ C | 0 = ax³ + bx² + cx + d}
     *
     * @author fenris
     */
    function cubic_solve_real(a: float, b: float, c: float, d: float): Array<lib_plankton.complex.type_complex>;
}
declare namespace lib_plankton.color {
    /**
     * @author fenris
     */
    type type_model_hsv = {
        hue: float;
        saturation: float;
        value: float;
    };
    /**
     * @author fenris
     */
    type type_model_hsl = {
        hue: float;
        saturation: float;
        lightness: float;
    };
    /**
     * @author fenris
     */
    type type_model_rgb = {
        red: float;
        green: float;
        blue: float;
    };
    /**
     * @author fenris
     */
    type type_color = {
        model: type_model_rgb;
    };
}
declare namespace lib_plankton.color {
    /**
     */
    function make_hsv({ "hue": hue, "saturation": saturation, "value": value }: {
        hue?: float;
        saturation?: float;
        value?: float;
    }): type_color;
    /**
     */
    function make_hsl(model_hsl: type_model_hsl): type_color;
    /**
     */
    function make_rgb(model_rgb: type_model_rgb): type_color;
    /**
     */
    function from_hex(hex: string): type_color;
    /**
     */
    function to_hsv(color: type_color): type_model_hsv;
    /**
     */
    function to_hsl(color: type_color): type_model_hsl;
    /**
     */
    function to_rgb(color: type_color): type_model_rgb;
    /**
     */
    function to_cmyk(color: type_color): type_model_rgb;
    /**
     */
    function add(color1: type_color, color2: type_color): type_color;
    /**
     */
    function multiply(color1: type_color, color2: type_color): type_color;
    /**
     * @todo blend through other model?
     */
    function blend(color1: type_color, color2: type_color, strength?: float): type_color;
    /**
     */
    function mix(color1: type_color, color2: type_color, { "strength1": option_strength1, "strength2": option_strength2, }?: {
        strength1?: float;
        strength2?: float;
    }): type_color;
    /**
     */
    function output_rgb(color: type_color): string;
    /**
     */
    function output_hex(color: type_color): string;
    /**
     */
    function output_dot(color: type_color): string;
    /**
     */
    function give_generic(n: int, { "offset": option_offset, "saturation": option_saturation, "value": option_value, }: {
        offset?: float;
        saturation?: float;
        value?: float;
    }): type_color;
    /**
     */
    function give_gray({ "value": option_value, }: {
        value?: float;
    }): type_color;
    /**
     */
    function give_black(): type_color;
    /**
     */
    function give_white(): type_color;
    /**
     */
    function give_red({ "saturation": option_saturation, "value": option_value, }?: {
        saturation?: float;
        value?: float;
    }): type_color;
    /**
     */
    function give_green({ "saturation": option_saturation, "value": option_value, }?: {
        saturation?: float;
        value?: float;
    }): type_color;
    /**
     */
    function give_blue({ "saturation": option_saturation, "value": option_value, }?: {
        saturation?: float;
        value?: float;
    }): type_color;
    /**
     */
    function give_yellow({ "saturation": option_saturation, "value": option_value, }?: {
        saturation?: float;
        value?: float;
    }): type_color;
    /**
     */
    function give_cyan({ "saturation": option_saturation, "value": option_value, }?: {
        saturation?: float;
        value?: float;
    }): type_color;
    /**
     */
    function give_magenta({ "saturation": option_saturation, "value": option_value, }?: {
        saturation?: float;
        value?: float;
    }): type_color;
}
declare namespace lib_plankton.http_base {
    /**
     */
    type type_request<type_method> = {
        scheme: ("http" | "https");
        host: (null | string);
        path: string;
        version: string;
        method: type_method;
        query: (null | string);
        headers: Record<string, string>;
        body: (null | Buffer);
    };
    /**
     */
    type type_response<type_status_code> = {
        version: (null | string);
        status_code: type_status_code;
        headers: Record<string, string>;
        body: (null | Buffer);
    };
}
declare namespace lib_plankton.http_base {
    /**
     */
    function encode_request<type_method>(encode_method: ((method: type_method) => string), request: type_request<type_method>): string;
    /**
     */
    function decode_request<type_method, type_request_actual>(decode_method: ((method_raw: string) => type_method), has_body: ((method: type_method) => boolean), request_raw: string): type_request<type_method>;
    /**
     */
    function encode_response<type_status_code>(encode_status_code: ((status_code: type_status_code) => string), get_status_text: ((status_code: type_status_code) => string), response: type_response<type_status_code>): string;
    /**
     */
    function decode_response<type_status_code>(decode_status_code: ((status_code_raw: string) => type_status_code), response_raw: string): type_response<type_status_code>;
    /**
     * executes an HTTP request
     *
     * @todo define type_signal
     */
    function call<type_method, type_status_code>(has_body: ((method: type_method) => boolean), encode_method: ((method: type_method) => string), decode_status_code: ((status_code_raw: string) => type_status_code), request: type_request<type_method>, { "timeout": option_timeout, "follow_redirects": option_follow_redirects, "implementation": option_implementation, }?: {
        timeout?: (null | float);
        follow_redirects?: boolean;
        implementation?: ("fetch" | "http_module");
    }): Promise<type_response<type_status_code>>;
}
declare namespace lib_plankton.http {
    /**
     * @author fenris <frass@greenscale.de>
     */
    enum enum_method {
        options = "options",
        head = "head",
        get = "get",
        delete = "delete",
        post = "post",
        put = "put",
        patch = "patch"
    }
    /**
     */
    enum enum_status_code {
        continue_ = 100,
        switching_protocols = 101,
        early_hints = 103,
        ok = 200,
        created = 201,
        accepted = 202,
        non_authoritative_information = 203,
        no_content = 204,
        reset_content = 205,
        partial_coentent = 206,
        multiple_choices = 300,
        moved_permanently = 301,
        found = 302,
        see_other = 303,
        not_modified = 304,
        temporary_redirect = 307,
        permanent_redirect = 308,
        bad_request = 400,
        unauthorized = 401,
        payment_required = 402,
        forbidden = 403,
        not_found = 404,
        method_not_allowed = 405,
        not_acceptable = 406,
        proxy_authentication_required = 407,
        request_timeout = 408,
        conflict = 409,
        gone = 410,
        length_required = 411,
        precondition_failed = 412,
        payload_too_large = 413,
        uri_too_long = 414,
        unsupported_media_type = 415,
        range_not_satisfiable = 416,
        expectation_failed = 417,
        i_m_a_teapot = 418,
        unprocessable_entity = 422,
        too_early = 425,
        upgrade_required = 426,
        precondition_required = 428,
        too_many_requests = 429,
        request_header_fields_too_large = 431,
        unavailable_for_legal_reasons = 451,
        internal_server_error = 500,
        not_implemented = 501,
        bad_gateway = 502,
        service_unavailable = 503,
        gateway_timeout = 504,
        http_version_not_supported = 505,
        variant_also_negotiates = 506,
        insufficient_storage = 507,
        loop_detected = 508,
        not_extended = 510,
        network_authentication = 511
    }
    /**
     * @author fenris <frass@greenscale.de>
     */
    type type_request = lib_plankton.http_base.type_request<enum_method>;
    /**
     * @author fenris <frass@greenscale.de>
     */
    type type_response = lib_plankton.http_base.type_response<enum_status_code>;
}
declare namespace lib_plankton.http {
    /**
     * @author fenris <frass@greenscale.de>
     */
    function encode_method(method: enum_method): string;
    /**
     * @author fenris <frass@greenscale.de>
     */
    function decode_method(method_raw: string): enum_method;
    /**
     * @author fenris <frass@greenscale.de>
     */
    function has_body(method: enum_method): boolean;
    /**
     * @author fenris <frass@greenscale.de>
     */
    function encode_request(request: type_request): string;
    /**
     * @author fenris <frass@greenscale.de>
     */
    function decode_request(request_raw: string): type_request;
    /**
     * @author fenris <frass@greenscale.de>
     */
    function encode_response(response: type_response): string;
    /**
     * @author fenris <frass@greenscale.de>
     */
    function decode_response(response_raw: string): type_response;
    /**
     * executes an HTTP request
     *
     * @todo define type_signal
     */
    function call(request: type_request, { "timeout": option_timeout, "follow_redirects": option_follow_redirects, "implementation": option_implementation, }?: {
        timeout?: (null | float);
        follow_redirects?: boolean;
        implementation?: ("fetch" | "http_module");
    }): Promise<type_response>;
}
declare namespace lib_plankton.pit {
    /**
     */
    type type_date = {
        year: int;
        month: int;
        day: int;
    };
    /**
     */
    type type_ywd = {
        year: int;
        week: int;
        day: int;
    };
    /**
     */
    type type_time = {
        hour: int;
        minute: int;
        second: int;
    };
    /**
     */
    type type_datetime = {
        timezone_shift: int;
        date: type_date;
        time: (null | type_time);
    };
    /**
     */
    type type_pit = int;
}
declare namespace lib_plankton.pit {
    /**
     * @todo complete
     */
    function timezone_name_to_timezone_shift(timezone_name: string): int;
    /**
     */
    function date_object_get_week_of_year(date: Date): int;
    /**
     */
    function to_unix_timestamp(pit: type_pit): int;
    /**
     */
    function from_unix_timestamp(unix_timestamp: int): type_pit;
    /**
     */
    function to_date_object(pit: type_pit): Date;
    /**
     */
    function from_date_object(date_object: Date): type_pit;
    /**
     * @todo test
     */
    function to_datetime(pit: type_pit, { "timezone_shift": option_timezone_shift, }?: {
        timezone_shift?: int;
    }): type_datetime;
    /**
     */
    function from_datetime(datetime: type_datetime): type_pit;
    /**
     */
    function is_before(pit: type_pit, reference: type_pit): boolean;
    /**
     */
    function is_after(pit: type_pit, reference: type_pit): boolean;
    /**
     */
    function is_equal_or_after(pit: type_pit, reference: type_pit): boolean;
    /**
     */
    function is_between(pit: type_pit, reference_left: type_pit, reference_right: type_pit): boolean;
    /**
     */
    function shift_second(pit: type_pit, increment: int): type_pit;
    /**
     */
    function shift_minute(pit: type_pit, increment: int): type_pit;
    /**
     */
    function shift_hour(pit: type_pit, increment: int): type_pit;
    /**
     */
    function shift_day(pit: type_pit, increment: int): type_pit;
    /**
     */
    function shift_week(pit: type_pit, increment: int): type_pit;
    /**
     */
    function shift_year(pit: type_pit, increment: int): type_pit;
    /**
     */
    function trunc_minute(pit: type_pit): type_pit;
    /**
     */
    function trunc_hour(pit: type_pit): type_pit;
    /**
     */
    function trunc_day(pit: type_pit): type_pit;
    /**
     */
    function trunc_week(pit: type_pit): type_pit;
    /**
     */
    function trunc_month(pit: type_pit): type_pit;
    /**
     */
    function trunc_year(pit: type_pit): type_pit;
    /**
     */
    function now(): type_pit;
    /**
     * @param year year according to specified timezone shift
     * @param week week according to specified timezone shift
     * @return the begin of the week (monday, 00:00)
     */
    function from_ywd(ywd: type_ywd, { "timezone_shift": option_timezone_shift, }?: {
        timezone_shift?: int;
    }): type_pit;
    /**
     * @todo timezone
     */
    function to_ywd(pit: type_pit, { "timezone_shift": option_timezone_shift, }?: {
        timezone_shift?: int;
    }): type_ywd;
    /**
     */
    function number_of_weeks(year: int): int;
    /**
     * computes the point in time for switching to central european summer time
     *
     * @todo write tests
     */
    function cest_switch_on(year: int): type_pit;
    /**
     * computes the point in time for switching away from central european summer time
     *
     * @todo write tests
     */
    function cest_switch_off(year: int): type_pit;
    /**
     */
    function timezone_shift_ce(pit: type_pit): int;
    /**
     * [convenience]
     */
    function to_datetime_ce(pit: type_pit): type_datetime;
    /**
     */
    function datetime_translate(datetime: type_datetime, timezone_shift: int): type_datetime;
    /**
     * [convenience]
     */
    function datetime_translate_ce(datetime: type_datetime): type_datetime;
    /**
     */
    function timezone_shift_format(timezone_shift: int): string;
    /**
     */
    function date_format(date: type_date, { "short": short, }?: {
        short?: boolean;
    }): string;
    /**
     */
    function time_format(time: type_time, { "show_seconds": option_show_seconds, }?: {
        show_seconds?: boolean;
    }): string;
    /**
     */
    function datetime_format(datetime: (null | type_datetime), { "timezone_indicator": option_timezone_indicator, "show_timezone": option_show_timezone, "adjust_to_ce": option_adjust_to_ce, "omit_date": option_omit_date, }?: {
        timezone_indicator?: string;
        show_timezone?: boolean;
        adjust_to_ce?: boolean;
        omit_date?: boolean;
    }): string;
    /**
     */
    function timespan_format(from: (null | type_datetime), to: (null | type_datetime), { "timezone_indicator": timezone_indicator, "show_timezone": show_timezone, "adjust_to_ce": adjust_to_ce, "omit_date": omit_date, "indicator_open_both": indicator_open_both, "indicator_open_right": indicator_open_right, "indicator_open_left": indicator_open_left, "indicator_closed": indicator_closed, }?: {
        timezone_indicator?: string;
        show_timezone?: boolean;
        adjust_to_ce?: boolean;
        omit_date?: boolean;
        indicator_open_both?: string;
        indicator_open_right?: string;
        indicator_open_left?: string;
        indicator_closed?: string;
    }): string;
}
declare namespace lib_plankton.translate {
    /**
     * @author fenris
     */
    type type_package_meta = {
        identifier: string;
        name?: string;
    };
    /**
     * @author fenris
     */
    type type_package = {
        meta: type_package_meta;
        tree: {
            [id: string]: string;
        };
    };
    /**
     * @desc the level of verbosity, specifiying how much output the system shall provide about its actions
     * @author fenris
     */
    var _verbosity: int;
    /**
     * @desc moves a language to the top of the order, making it the primary one
     * @author fenris
     */
    function promote(identifier: string): void;
    /**
     * @desc adds a package to the sytem
     * @author fenris
     */
    function add(package_: type_package): void;
    /**
     * @desc integrates a package to the system, i.e. creates a new one if none existed so far or merges with an existing one
     * @author fenris
     */
    function feed(package_: type_package): void;
    /**
     * @desc tries to retrieve a translation for a specific package identifier
     * @author fenris
     */
    function fetch(identifier: string, path: string, args?: {
        [id: string]: string;
    }): lib_plankton.pod.type_pod<string>;
    /**
     * @desc retrieves a string by going through the order and trying to fetch it for the current entry
     * @author fenris
     * @todo rename to "get"
     */
    function get_new(path: string, { "args": args, "preferred_language": preferred_language, "fallback": fallback, }?: {
        args?: Record<string, string>;
        preferred_language?: (null | string);
        fallback?: string;
    }): string;
    /**
     * @desc retrieves a string by going through the order and trying to fetch it for the current entry
     * @author fenris
     * @deprecated use "get_new"
     * @todo remove
     */
    function get(path: string, args?: {
        [id: string]: string;
    }, fallback?: string): string;
    /**
     * @author fenris
     */
    function list(): Array<type_package_meta>;
    /**
     * @author fenris
     * @todo get rid of this; it's currenly needed only for the cdh-internal lib_completion
     */
    function paths(): Array<string>;
    /**
     * @author fenris
     */
    function initialize({ "logprefix": logprefix, "verbosity": verbosity, "packages": packages, "order": order, "autopromote": autopromote, }?: {
        logprefix?: string;
        verbosity?: int;
        packages?: Array<type_package>;
        order?: Array<string>;
        autopromote?: boolean;
    }): Promise<void>;
}
declare namespace lib_plankton.translate {
    /**
     * @author fenris
     */
    function iso_639_1_to_iso_639_2(iso6391: string): string;
    /**
     * @author fenris
     */
    function stance(str: string): string;
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    interface interface_widget {
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_empty implements interface_widget {
        /**
         */
        constructor();
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_string implements interface_widget {
        /**
         */
        private content;
        /**
         */
        constructor(content: string);
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_link implements interface_widget {
        /**
         */
        private target;
        /**
         */
        private text;
        /**
         */
        private open_in_new_tab;
        /**
         */
        constructor(target: string, { "text": text, "open_in_new_tab": open_in_new_tab, }?: {
            text?: (null | string);
            open_in_new_tab?: boolean;
        });
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_text implements interface_widget {
        /**
         */
        private paragraphs;
        /**
         */
        constructor(paragraphs: Array<string>);
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_list implements interface_widget {
        /**
         */
        private elements;
        /**
         */
        constructor(elements: Array<interface_widget>);
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_panel implements interface_widget {
        /**
         */
        private content;
        /**
         */
        private collapseable;
        /**
         */
        private collapsed_initial_value;
        /**
         */
        private classes;
        /**
         */
        constructor(content: interface_widget, { "collapseable": collapseable, "collapsed_initial_value": collapsed_initial_value, "classes": classes, }?: {
            collapseable?: boolean;
            collapsed_initial_value?: boolean;
            classes?: Array<string>;
        });
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_panel_info extends class_panel {
        /**
         */
        constructor(content: interface_widget, { "collapseable": collapseable, "collapsed_initial_value": collapsed_initial_value, "classes": classes, }?: {
            collapseable?: boolean;
            collapsed_initial_value?: boolean;
            classes?: Array<string>;
        });
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_panel_warning extends class_panel {
        /**
         */
        constructor(content: interface_widget, { "collapseable": collapseable, "collapsed_initial_value": collapsed_initial_value, "classes": classes, }?: {
            collapseable?: boolean;
            collapsed_initial_value?: boolean;
            classes?: Array<string>;
        });
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_panel_error extends class_panel {
        /**
         */
        constructor(content: interface_widget, { "collapseable": collapseable, "collapsed_initial_value": collapsed_initial_value, "classes": classes, }?: {
            collapseable?: boolean;
            collapsed_initial_value?: boolean;
            classes?: Array<string>;
        });
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_panel_success extends class_panel {
        /**
         */
        constructor(content: interface_widget, { "collapseable": collapseable, "collapsed_initial_value": collapsed_initial_value, "classes": classes, }?: {
            collapseable?: boolean;
            collapsed_initial_value?: boolean;
            classes?: Array<string>;
        });
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_bunch implements interface_widget {
        /**
         */
        private elements;
        /**
         */
        constructor(elements: Array<interface_widget>);
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_widget {
    /**
     */
    class class_slider implements interface_widget {
        /**
         */
        private conf;
        /**
         */
        private state;
        /**
         */
        constructor(content: Array<interface_widget>, { "threshold": threshold, "acceleration_function": acceleration_function, "initial_index": initial_index, }?: {
            threshold?: float;
            acceleration_function?: ((float: any) => float);
            initial_index?: int;
        });
        /**
         */
        private static cap;
        /**
         */
        private static position_subtract;
        /**
         */
        private static touch_event_position;
        /**
         */
        private set_translation;
        /**
         */
        private start;
        /**
         */
        private update;
        /**
         */
        private finish;
        /**
         */
        load(target_element: HTMLElement): Promise<void>;
    }
}
declare namespace lib_plankton.zoo_page {
    /**
     */
    export type type_location = {
        name: string;
        parameters: Record<string, any>;
    };
    /**
     */
    type type_handler = ((parameters: Record<string, any>, target_element: Element) => void);
    /**
     */
    type type_nav_entry_definition = {
        location: type_location;
        label: string;
        groups: Array<string>;
    };
    /**
     */
    export let _pool: Record<string, type_handler>;
    /**
     */
    export function encode(location: type_location): string;
    /**
     * encodes a location in the URL and loads it
     */
    export function set(location: type_location): void;
    /**
     */
    export function reload(): Promise<void>;
    /**
     */
    export function register(location_name: string, handler: type_handler): void;
    /**
     */
    export function nav_set_groups(groups: (null | Array<string>)): void;
    /**
     */
    export function init(target_element: Element, { "pool": pool, "fallback": fallback, "nav_entries": nav_entries, "nav_initial_groups": nav_initial_groups, }?: {
        pool?: Record<string, type_handler>;
        fallback?: (null | type_location);
        nav_entries?: Array<type_nav_entry_definition>;
        nav_initial_groups?: (null | Array<string>);
    }): void;
    /**
     */
    export function start(): void;
    export {};
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    interface interface_input<type_value> {
        /**
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         */
        read(): Promise<type_value>;
        /**
         */
        write(value: type_value): Promise<void>;
        /**
         */
        lock(mode: boolean): Promise<void>;
        /**
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    abstract class class_input_simple<type_value> implements interface_input<type_value> {
        /**
         */
        private dom_input;
        /**
         */
        private type;
        /**
         */
        private decode;
        /**
         */
        private encode;
        /**
         */
        private additional_attributes?;
        /**
         */
        constructor(type: string, decode: ((representation: string) => type_value), encode: ((value: type_value) => string), { "additional_attributes": additional_attributes, }?: {
            additional_attributes?: Record<string, (null | string)>;
        });
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<type_value>;
        /**
         * [implementation]
         */
        write(value: type_value): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_wrapped<type_value_inner, type_value_outer> implements interface_input<type_value_outer> {
        /**
         */
        private core;
        /**
         */
        private wrap;
        /**
         */
        private unwrap;
        /**
         */
        constructor(core: interface_input<type_value_inner>, wrap: ((value_inner: type_value_inner) => type_value_outer), unwrap: ((value_outer: type_value_outer) => type_value_inner), options?: {});
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<type_value_outer>;
        /**
         * [implementation]
         */
        write(value: type_value_outer): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_soft<type_value_core> implements interface_input<(null | type_value_core)> {
        /**
         */
        private read_only;
        /**
         */
        private core;
        /**
         */
        private dom_set;
        /**
         */
        private dom_wrapper;
        /**
         */
        constructor(core: interface_input<type_value_core>, { "read_only": read_only, }?: {
            read_only?: boolean;
        });
        /**
         */
        private toggle;
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<(null | type_value_core)>;
        /**
         * [implementation]
         */
        write(value: (null | type_value_core)): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_hidden implements interface_input<any> {
        /**
         */
        private dom_input;
        /**
         */
        private value;
        /**
         */
        constructor({ "initial_value": initial_value, }?: {
            initial_value?: any;
        });
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<any>;
        /**
         * [implementation]
         */
        write(value: any): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     * @todo abstract
     */
    class class_input_text extends class_input_simple<string> implements interface_input<string> {
        /**
         */
        constructor({ "pattern": pattern, "placeholder": placeholder, }?: {
            pattern?: (null | string);
            placeholder?: (null | string);
        });
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_email extends class_input_simple<string> implements interface_input<string> {
        /**
         */
        constructor();
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_textarea implements interface_input<string> {
        /**
         */
        private dom_textarea;
        /**
         */
        constructor();
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<string>;
        /**
         * [implementation]
         */
        write(value: string): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_date implements interface_input<(null | lib_plankton.pit.type_date)> {
        /**
         */
        private required;
        /**
         */
        private dom_input;
        /**
         */
        constructor({ "required": required, }?: {
            required?: boolean;
        });
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<(null | lib_plankton.pit.type_date)>;
        /**
         * [implementation]
         */
        write(value: (null | lib_plankton.pit.type_date)): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     * @todo abstract
     */
    class class_input_number extends class_input_simple<number> implements interface_input<number> {
        /**
         */
        constructor({ "step": step, }?: {
            step?: (null | float);
        });
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_checkbox implements interface_input<boolean> {
        /**
         */
        private dom_input;
        /**
         */
        constructor();
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<boolean>;
        /**
         * [implementation]
         */
        write(value: boolean): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_selection implements interface_input<string> {
        /**
         */
        private options;
        /**
         */
        private dom_select;
        /**
         */
        constructor(options: Array<{
            value: string;
            label: string;
        }>);
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<string>;
        /**
         * [implementation]
         */
        write(value: string): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_enumeration<type_value> implements interface_input<type_value> {
        /**
         */
        private encode_value;
        /**
         */
        private decode_value;
        /**
         */
        private options;
        /**
         */
        private dom_inputs;
        /**
         */
        constructor(encode_value: ((value: type_value) => string), decode_value: ((representation: string) => type_value), options: Array<{
            value: type_value;
            label: string;
        }>);
        /**
         * [implementation]
         * @todo unique name
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<type_value>;
        /**
         * [implementation]
         */
        write(value: type_value): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     */
    type type_translations = {
        add?: string;
        remove?: string;
    };
    /**
     * @author fenris
     */
    export class class_input_list<type_element> implements interface_input<Array<type_element>> {
        /**
         */
        private read_only;
        /**
         */
        private element_input_factory;
        /**
         */
        private elements_container_dom;
        /**
         */
        private elements;
        /**
         */
        private translations;
        /**
         */
        private locked;
        /**
         */
        constructor(element_input_factory: (() => interface_input<type_element>), { "read_only": read_only, "translations": translations, }?: {
            read_only?: boolean;
            translations?: type_translations;
        });
        /**
         */
        private clear;
        /**
         */
        private add;
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<Array<type_element>>;
        /**
         * [implementation]
         */
        write(value: Array<type_element>): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
    export {};
}
declare namespace lib_plankton.zoo_input {
    /**
     */
    class class_input_set implements lib_plankton.zoo_input.interface_input<Set<string>> {
        /**
         */
        private options;
        /**
         */
        private show_element;
        /**
         */
        private read_only;
        /**
         */
        private checkboxes;
        /**
         */
        constructor(options: Array<string>, show_element: ((element: string) => string), { "read_only": read_only, }?: {
            read_only?: boolean;
        });
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<Set<string>>;
        /**
         * [implementation]
         */
        write(value: Set<string>): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_password implements interface_input<string> {
        /**
         */
        private exhibit;
        /**
         */
        private character_hide;
        /**
         */
        private character_show;
        /**
         */
        private dom_input;
        /**
         */
        private dom_exhibit;
        /**
         */
        constructor({ "exhibit_initial_value": exhibit_initial_value, "character_hide": character_hide, "character_show": character_show, }?: {
            exhibit_initial_value?: boolean;
            character_hide?: string;
            character_show?: string;
        });
        /**
         */
        private toggle_exhibition;
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<string>;
        /**
         * [implementation]
         */
        write(value: string): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_switch implements interface_input<boolean> {
        /**
         */
        private dom_element;
        /**
         */
        private value;
        /**
         */
        private symbols;
        /**
         */
        constructor({ "symbols": symbols, }?: {
            symbols?: {
                yes: string;
                no: string;
            };
        });
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<boolean>;
        /**
         * [implementation]
         */
        write(value: boolean): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_time extends class_input_simple<(null | lib_plankton.pit.type_time)> implements interface_input<(null | lib_plankton.pit.type_time)> {
        /**
         */
        constructor();
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_group<type_record> implements interface_input<type_record> {
        /**
         */
        private fields;
        /**
         */
        constructor(fields_raw: Array<{
            name: string;
            input: interface_input<any>;
            label?: (null | string);
            help?: (null | lib_plankton.zoo_widget.interface_widget);
        }>);
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<type_record>;
        /**
         * [implementation]
         */
        write(value: type_record): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     */
    class class_input_hashmap<type_key, type_value> implements interface_input<lib_plankton.map.type_map<type_key, type_value>> {
        /**
         */
        private hash_key;
        /**
         */
        private core;
        /**
         */
        constructor(hash_key: ((key: type_key) => string), key_input_factory: (() => interface_input<type_key>), value_input_factory: (() => interface_input<type_value>));
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<lib_plankton.map.type_map<type_key, type_value>>;
        /**
         * [implementation]
         */
        write(map: lib_plankton.map.type_map<type_key, type_value>): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     */
    class class_input_datetime implements interface_input<lib_plankton.pit.type_datetime> {
        /**
         */
        private core;
        /**
         */
        constructor({ "label_timezone_shift": label_timezone_shift, "label_date": label_date, "label_time": label_time, }?: {
            label_timezone_shift?: string;
            label_date?: string;
            label_time?: string;
        });
        /**
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         */
        read(): Promise<lib_plankton.pit.type_datetime>;
        /**
         */
        write(value: lib_plankton.pit.type_datetime): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * for central europe with daylight saving time feature
     */
    class class_input_datetime_central_europe implements interface_input<lib_plankton.pit.type_datetime> {
        /**
         */
        private core;
        /**
         */
        constructor({ "label_date": label_date, "label_time": label_time, }?: {
            label_date?: string;
            label_time?: string;
        });
        /**
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         */
        read(): Promise<lib_plankton.pit.type_datetime>;
        /**
         */
        write(value: lib_plankton.pit.type_datetime): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     */
    class class_input_color extends class_input_simple<(null | lib_plankton.color.type_color)> implements interface_input<(null | lib_plankton.color.type_color)> {
        /**
         */
        constructor();
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     */
    class class_input_hue extends class_input_wrapped<(null | lib_plankton.color.type_color), (null | float)> implements interface_input<(null | float)> {
        /**
         */
        constructor();
    }
}
declare namespace lib_plankton.zoo_input {
    /**
     * @author fenris
     */
    class class_input_file implements interface_input<(null | string | ArrayBuffer)> {
        /**
         */
        private required;
        /**
         */
        private mime_type;
        /**
         */
        private capture;
        /**
         */
        private dom_input;
        /**
         */
        constructor({ "required": required, "mime_type": mime_type, "capture": capture, }?: {
            required?: boolean;
            mime_type?: (null | string);
            capture?: boolean;
        });
        /**
         * [implementation]
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         * [implementation]
         */
        read(): Promise<(null | string | ArrayBuffer)>;
        /**
         * [implementation]
         */
        write(value: (null | string | ArrayBuffer)): Promise<void>;
        /**
         * [implementation]
         */
        lock(mode: boolean): Promise<void>;
        /**
         * [implementation]
         */
        hook_change(action: (() => void)): Promise<void>;
        /**
         * [implementation]
         */
        focus(): void;
    }
}
declare namespace lib_plankton.zoo_form {
    /**
     */
    type type_field = {
        name: string;
        type: string;
        label: (null | string);
    };
    /**
     */
    export type type_form<type_value> = {
        method: string;
        fields: Array<type_field>;
        encode: ((value: type_value) => Record<string, string>);
        decode: ((raw: Record<string, string>) => type_value);
        class_prefix: string;
        root_element: (null | Element);
    };
    /**
     */
    export function make<type_value>(method: string, fields: Array<{
        name: string;
        type: string;
        label?: (null | string);
    }>, encode: ((value: type_value) => Record<string, string>), decode: ((raw: Record<string, string>) => type_value), { "class_prefix": class_prefix, }?: {
        class_prefix?: string;
    }): type_form<type_value>;
    /**
     */
    export function make_simple(method: string, fields: Array<{
        name: string;
        type: string;
        label?: (null | string);
    }>, options?: {
        class_prefix?: string;
    }): type_form<Record<string, any>>;
    /**
     */
    export function clear<type_value>(subject: type_form<type_value>): void;
    /**
     */
    export function write<type_value>(subject: type_form<type_value>, value: type_value): void;
    /**
     */
    export function read<type_value>(subject: type_form<type_value>): type_value;
    /**
     */
    export function render<type_value>(subject: type_form<type_value>, target: Element): Promise<void>;
    export {};
}
declare namespace lib_plankton.zoo_form {
    /**
     */
    type type_action<type_value, type_representation> = {
        label: string;
        target?: string;
        procedure?: ((get_value?: (() => Promise<type_value>), get_representation?: (() => Promise<type_representation>)) => void);
    };
    /**
     * @author fenris
     */
    export class class_form<type_value, type_representation> {
        /**
         */
        private encode;
        /**
         */
        private decode;
        /**
         */
        private actions;
        /**
         */
        private input;
        /**
         */
        constructor(encode: ((value: type_value) => type_representation), decode: ((representation: type_representation) => type_value), input: lib_plankton.zoo_input.interface_input<type_representation>, actions: Array<type_action<type_value, type_representation>>);
        /**
         */
        setup(parent: HTMLElement): Promise<void>;
        /**
         */
        input_read_raw(): Promise<type_representation>;
        /**
         */
        input_read(): Promise<type_value>;
        /**
         */
        input_write(value: type_value): Promise<void>;
        /**
         */
        input_lock(mode: boolean): Promise<void>;
        /**
         */
        input_focus(): void;
    }
    export {};
}
