local record pl
    -- This is not divided into multiple files due to circular
    -- dependency issues. For now, everything is declared here
    -- and just reexported in the right file

    record List<T>
      --   {T}

        new: function({T}): pl.List<T>
        metamethod __call: function<T>(any, {T}): pl.List<T>
        metamethod __concat: function(pl.List<T>, pl.List<T>): pl.List<T>
        metamethod __len: function(pl.List<T>): number
        metamethod __index: function(pl.List<T>, number): T

        range: function(number, number, number): pl.List<number>
        split: function(string, string): pl.List<string>

        len: function(pl.List<T>): number

        append: function(pl.List<T>, T): pl.List<T>
        clone: function(pl.List<T>): pl.List<T>
        extend: function(pl.List<T>, pl.List<T>): pl.List<T>
        insert: function(pl.List<T>, number, T): pl.List<T>
        pop: function(pl.List<T>, number): T
        put: function(pl.List<T>, T): pl.List<T>
        remove: function(pl.List<T>, number): pl.List<T>
        remove_value: function(pl.List<T>, T): pl.List<T>

        chop: function(pl.List<T>, number, number): pl.List<T>
        slice_assign: function(pl.List<T>, number, number, pl.List<T>): pl.List<T>
        splice: function(pl.List<T>, number, pl.List<T>): pl.List<T>

        reverse: function(pl.List<T>): pl.List<T>
        sorted: function(pl.List<T>, string | function(T, T): boolean): pl.List<T>
        sort: function(pl.List<T>, string | function(T, T): boolean): pl.List<T>

        clear: function(pl.List<T>): pl.List<T>
        contains: function(pl.List<T>, T): boolean
        count: function(pl.List<T>, T): number
        index: function(pl.List<T>, T, number): number
        minmax: function(pl.List<T>): number, number
        slice: function(pl.List<T>, number, number): pl.List<T>

        concat: function(pl.List<T>, string): string
        join: function(pl.List<T>, string): string

        foreach: function(pl.List<T>, string | function(T, ...: any), ...: any)
        foreachm: function(pl.List<table>, string, ...: any)
        filter: function<U>(pl.List<T>, (string | function(T, U): boolean), U): pl.List<T>

        transform: function(pl.List<T>, (string | function(T, ...: any): T), ...: any): pl.List<T>

        map: function<U>(pl.List<T>, (string | function(T, ...: any): U), ...: any): pl.List<U>
        map2: function<U, V>(pl.List<T>, (string | function(T, U, ...: any): V), pl.List<U>, ...: any): pl.List<V>
        mapm: function<U>(pl.List<T>, string, ...: any): pl.List<U>
        reduce: function(pl.List<T>, (string | function(T, T): T)): T

        partition: function<K>(List<T>, (function(T, ...: any): K), ...: any): pl.Map<K, List<T> >

        iter: function(pl.List<T>): (function(): T)
        iterate: function(string | table | function) -- FILE is also considered a table
    end

    record Map<K, V>
        metamethod __call: function<K, V>(any, {K: V}): Map<K, V>

        -- These two are substitutes for maprecords ({K: V})
        metamethod __index: function(pl.Map<K, V>, K): V
        metamethod __newindex: function(pl.Map<K, V>, K, V)

        keys: pl.List<K>
        values: pl.List<V>

        iter: function(pl.Map<K, V>): (function(): K, V)
        items: function(pl.Map<K, V>): (function(): {K, V})

        get: function(pl.Map<K, V>, K): V
        set: function(pl.Map<K, V>, K, V)
        setdefault: function(pl.Map<K, V>, K, V): V

        getvalues: function(pl.Map<K, V>, {K}): pl.List<V>
        update: function(pl.Map<K, V>, {K: V})

        len: function(pl.Map<K, V>): number
    end

    record Date
        metamethod __call: function(pl.Date, number, boolean): pl.Date
        metamethod __call: function(pl.Date, {pl.Date.datefield: number}, boolean): pl.Date
        metamethod __call: function(pl.Date, number, number, number, number, number, number)

        metamethod __lt: function(pl.Date, pl.Date): boolean
        metamethod __add: function(pl.Date, pl.Date): pl.Date
        metamethod __add: function(pl.Date, {pl.Date.datefield: number}): pl.Date
        metamethod __sub: function(pl.Date, pl.Date): pl.Date

        enum datefield
            'year'
            'month'
            'day'
            'hour'
            'min'
            'sec'
        end

        set: function(pl.Date, number)
        tzone: function(pl.Date, number): number
        toUTC: function(pl.Date): pl.Date
        toLocal: function(pl.Date): pl.Date

        year: function(pl.Date): number
        month: function(pl.Date): number
        day: function(pl.Date): number
        hour: function(pl.Date): number
        min: function(pl.Date): number
        sec: function(pl.Date): number
        yday: function(pl.Date): number

        year: function(pl.Date, number)
        month: function(pl.Date, number)
        day: function(pl.Date, number)
        hour: function(pl.Date, number)
        min: function(pl.Date, number)
        sec: function(pl.Date, number)
        yday: function(pl.Date, number)

        is_weekend: function(pl.Date): boolean
        weekday_name: function(pl.Date, boolean): string
        month_name: function(pl.Date, boolean): string

        add: function(pl.Date, {pl.Date.datefield: number})
        diff: function(pl.Date, pl.Date): pl.Date

        last_day: function(pl.Date): number

        Interval: function(number): pl.Date

        record Format
            metamethod __call: function(string): pl.Date.Format
            parse: function(string): pl.Date
            tostring: function(pl.Date): string
            US_order: function(boolean)
        end
    end

    -- MultiMap inherits from Map, so this is just a weird case that can't
    -- really be easily described in teal for now. Same for OrderedMap and Set.

    -- TODO MultiMap
    -- TODO OrderedMap
    -- TODO Set

    record app
        script_name: function(): string
        require_here: function(string): any
        appfile: function(string): string
        platform: function(): string
        lua: function(): string, string
        parse_args: function({string}, table, table)
    end

    record array2d
        record Array2D<T> -- record just for generics
            {{T}}
        end

        new: function<T>(number, number, T): Array2D<T>

        size: function<T>(pl.array2d.Array2D<T>): number, number
        column: function<T>(pl.array2d.Array2D<T>, number): List<T>
        flatten: function<T>(pl.array2d.Array2D<T>): List<T>
        reshape: function<T>(pl.array2d.Array2D<T>, number, boolean): pl.array2d.Array2D<T>

        swap_rows: function<T>(pl.array2d.Array2D<T>, number, number)
        swap_cols: function<T>(pl.array2d.Array2D<T>, number, number)

        reduce_rows: function<T>(function(T, T): T, pl.array2d.Array2D<T>): pl.List<T>
        reduce_cols: function<T>(function(T, T): T, pl.array2d.Array2D<T>): pl.List<T>
        reduce2: function<T>(function(T, T): T, function(T, T): T, pl.array2d.Array2D<T>): T

        map: function<T, R, A>(
            (string | function<U>(T, ...: A): R),
            pl.array2d.Array2D<T>, ...: A
        ): pl.array2d.Array2D<R>

        map2: function<T1, T2, R, A>(
            (string | function({T1}, {T2}, ...: A): {R}),
            number, number,
            pl.array2d.Array2D<T1>, pl.array2d.Array2D<T2>,
            ...: A
        ): pl.array2d.Array2D<R>
        map2: function<T1, T2, R, A>(
            (string | function({T1}, {T2}, ...: A): R),
            number, number,
            pl.array2d.Array2D<T1>, {T2},
            ...: A
        ): Array2D<R>
        map2: function<T1, T2, R, A>(
            (string | function({T1}, {T2}, ...: A): R),
            number, number,
            {T1}, pl.array2d.Array2D<T2>,
            ...: A
        ): pl.array2d.Array2D<R>
        map2: function<T1, T2, R, A>(
            (string | function({T1}, {T2}, ...: A): R),
            number, number,
            {T1}, {T2},
            ...: A
        ): {R}

        product: function<T, U, R>(
            (string | function(T, U): R),
            {T}, {U}
        ): pl.array2d.Array2D<R>

        extract_rows: function<T>(pl.array2d.Array2D<T>, {number}): pl.array2d.Array2D<T>
        extract_cols: function<T>(pl.array2d.Array2D<T>, {number}): pl.array2d.Array2D<T>

        remove_row: function<T>(pl.array2d.Array2D<T>, number)
        remove_col: function<T>(pl.array2d.Array2D<T>, number)

        parse_range: function(string): number, number, number, number
        range: function<T>(pl.array2d.Array2D<T>, string): {T}
        slice: function<T>(pl.array2d.Array2D<T>, number, number, number, number): {T}
        set: function<T>(pl.array2d.Array2D<T>, T, number, number, number, number)
        write: function<T>(pl.array2d.Array2D<T>, FILE, string, number, number, number, number)

        forall: function<T>(
            pl.array2d.Array2D<T>,
            (function({T}, number): any...),
            (function(number): any...),
            number, number, number, number
        )
        move: function<T>(
            pl.array2d.Array2D<T>,
            number, number,
            pl.array2d.Array2D<T>,
            number, number, number, number
        )

        iter: function<T>(
            pl.array2d.Array2D<T>, boolean,
            number, number, number, number
        ): (function(): (T | {number, number, T}))

        columns: function<T>(pl.array2d.Array2D<T>): (function(): List<T>)
    end

    record class
        metamethod __index: function(any, string): Class
        metamethod __call: function(any, Class): Class

        record Class
            class_of: function(Class, Instance): boolean
            cast: function(Class, Instance)
        end

        record Instance
            -- FIXME this is not ideal, but I can't think of a better solution...
            metamethod __index: function(Instance, any): any

            is_a: function(Instance, Class): boolean
        end
    end

    record compat
        lua51: boolean
        jit: boolean
        jit52: boolean
        is_windows: boolean

        dir_separator: string

        execute: function(string): boolean, number

        enum LoadMode
            'b'
            't'
            'bt'
        end
        load: function(any, string, LoadMode, {string: any})

        getfenv: function(function): {string: any}
        setfenv: function(function, {string: any})
    end

    record comprehension
        type generator = (function(): {any})
        type parser = (function(string): generator)
        new: function(): parser
    end

    record config
        enum ReadOpt
            'smart'
            'variabilize'
            'convert_numbers'
            'trim_space'
            'trim_quotes'
            'list_delim'
            'keysep'
        end

        enum ReadError
            'not a file-like object'
            'file is nil'
        end

        lines: function(FILE | string): function(): string, pl.config.ReadError
        read: function(FILE | string, {pl.config.ReadOpt: any}): table, pl.config.ReadError
    end

    record data
        enum ReadOpt
            'delim'
            'fieldnames'
            'no_convert'
            'convert'
            'numfields'
            'last_field_collect'
            'thousands_dot'
            'csv'
        end

        type rowiterator = function(): any...

        record Data
            {{any}}

            fieldnames: pl.List<string>
            original_fieldnames: {string}

            column_by_name: function(pl.data.Data, string): pl.List<any>

            select: function(pl.data.Data, string): pl.data.rowiterator
            select_row: function(pl.data.Data, string): function(): {any}

            copy_select: function(pl.data.Data, string): Data
            column_names: function(pl.data.Data): {string}

            write_row: function(pl.data.Data, FILE, {any})

            write: function(pl.data.Data, FILE)
            read: function(FILE | string, {pl.data.ReadOpt: any}): pl.data.Data, string
        end
        write: function(array2d.Array2D, FILE, {string}, string): boolean, string

        new: function({{any}}, {string})

        query: function(pl.data.Data, (string | table), {table}, boolean): pl.data.rowiterator, string
        filter: function(string, FILE | string, FILE | string, boolean)
    end

    record dir
        fnmatch: function(string, string): boolean
        filter: function({string}, string): pl.List<string>

        copyfile: function(string, string, boolean): boolean
        movefile: function(string, string): boolean
        makepath: function(string): boolean, string
        rmtree: function(string): boolean, string
        clonetree: function(string, string, (function(string, string): any))

        getfiles: function(string, string): pl.List<string>
        getdirectories: function(string): pl.List<string>
        walk: function(string, boolean, boolean): (function(): string, pl.List<string>, pl.List<string>)

        dirtree: function(string): (function(): string, boolean)
        getallfiles: function(string, string): pl.List<string>
    end

    record file
        -- TODO copy declarations from other functions
        -- this whole module is just renaming of other functions
        read: function(string, boolean): string | nil, string
        write: function(filename: string, str: string, is_bin: boolean): boolean | nil, string
    end

    record func
        record PHExp end

        _0: pl.func.PHExp
        _1: pl.func.PHExp
        _2: pl.func.PHExp
        _3: pl.func.PHExp
        _4: pl.func.PHExp
        _5: pl.func.PHExp

        -- FIXME properly define return type of this... thing
        import: function(string, {any: function})
        register: function(function, string): function

        tail: function<T>({T}): {T}

        isPE: function(table): boolean
        repr: function(pl.func.PHExp): string
        instantiate: function(pl.func.PHExp): function
        I: function(pl.func.PHExp): function

        -- FIXME this is horrible...
        bind1: function<T, U>((function(T): U), T): (function(): U)
        bind1: function<T1, T2, U>((function(T1, T2): U), T1): (function(T2): U)
        bind1: function<T1, T2, T3, U>(
            (function(T1, T2, T3): U),
            T1
        ): (function(T2, T3): U)
        bind1: function<T1, T2, T3, T4, U>(
            (function(T1, T2, T3, T4): U),
            T1
        ): (function(T2, T3, T4): U)
        bind1: function<T1, T2, T3, T4, T5, U>(
                (function(T1, T2, T3, T4, T5): U), T1
            ): (function(T2, T3, T4, T5): U)
        bind1: function<T1, T2, T3, T4, T5, T6, U>(
                (function(T1, T2, T3, T4, T5, T6): U), T1
            ): (function(T2, T3, T4, T5, T6): U)

        -- FIXME Will these screw up the above definitions?
        bind1: function<T, U>((function(...: T): U), T): (function(...: T): U)

        compose: function<T, U, V>(
            (function(T): U),
            (function(U): V)
        ): (function(T): V)

        -- FIXME same as above
        compose: function<T, U, V>(
            (function(...: T): U...),
            (function(...: U): V...)
        ): (function(...: T): V...)
        compose: function(
            (function(...: any): any...),
            (function(...: any): any...)
        ): (function(...: any): any...)

        -- FIXME same as above
        bind: function<T, U>((function(T, ...: any): U), T): (function(...: any): U)

        bind: function<T1, T2, U>((function(T1, T2, ...: any): U), T1, T2): (function(...: any): U)
        bind: function<T1, T2, U>((function(T1, T2, ...: any): U), pl.func.PHExp, T2): (function(T1, ...: any): U)

        -- This is literally exponential, I am NOT doing a 4 parameter version
        bind: function<T1, T2, T3, U>((function(T1, T2, T3, ...: any): U), T1, T2, T3): (function(...: any): U)
        bind: function<T1, T2, T3, U>((function(T1, T2, T3, ...: any): U), pl.func.PHExp, T2, T3): (function(T1, ...: any): U)
        bind: function<T1, T2, T3, U>((function(T1, T2, T3, ...: any): U), T1, pl.func.PHExp, T3): (function(T2, ...: any): U)
        bind: function<T1, T2, T3, U>((function(T1, T2, T3, ...: any): U), pl.func.PHExp, pl.func.PHExp, T3): (function(T1, T2, ...: any): U)
        bind: function<T1, T2, T3, U>((function(T1, T2, T3, ...: any): U), T1, T2, pl.func.PHExp): (function(T3, ...: any): U)
        bind: function<T1, T2, T3, U>((function(T1, T2, T3, ...: any): U), pl.func.PHExp, T2, pl.func.PHExp): (function(T1, T3, ...: any): U)
        bind: function<T1, T2, T3, U>((function(T1, T2, T3, ...: any): U), T1, pl.func.PHExp, pl.func.PHExp): (function(T2, T3, ...: any): U)
    end

    import_into: function(table): (table, table)

    record input
        type linegetter = function(...: any): string
        type source = string | table

        enum FieldsOpt
            'no_fail'
        end

        alltokens: function<T>(pl.input.linegetter, string, function(string): T): (function(): T)
        create_getter: function(source): pl.input.linegetter
        numbers: function(source): (function(): number)
        words: function(source): (function(): string)

        -- {fields, nil} is a hacky substitute for a 1-tuple type
        fields: function({number, nil}, string, source, {pl.input.FieldsOpt: any}): (function(): string)
        fields: function(
            {number, number},
            string,
            source,
            {pl.input.FieldsOpt: any}
        ): (function(): string, string)
        fields: function(
            {number, number, number},
            string,
            source,
            {pl.input.FieldsOpt: any}
        ): (function(): string, string, string)
        fields: function(
            {number, number, number, number},
            string,
            source,
            {pl.input.FieldsOpt: any}
        ): (function(): string, string, string, string)
        fields: function(
            {number} | number,
            string,
            source,
            {pl.input.FieldsOpt: any}
        ): (function(): string...)
    end

    record lapp
        enum argtype
            'string'
            'number'
            'file'
            'file-in'
            'boolean'
        end

        show_usage_error: boolean

        quit: function(string, boolean)
        open: function(string, string): FILE
        error: function(string, boolean)
        assert: function(boolean, string)
        add_type: function(string, (argtype | function(string): any), function(any))
        process_options_string: function(string, {string}): {string: any}

        metamethod __call: function(pl.lapp, string, {string}): {string: any}
    end

    record lexer
        type token = {string, string}
        type tokenaction = function(string, {string: any}): (string, string)
        type tokendesc = {string, pl.lexer.tokenaction}
        type tokenstream = function(any): (string, string)

        scan: function(
            string | FILE,
            {tokendesc, tokenaction},
            {string: boolean},
            {string: any}
        ): tokenstream
        lua: function(
            string | FILE,
            {string: boolean},
            {string: any}
        )
        cpp: function(
            string | FILE,
            {string: boolean},
            {string: any}
        )

        insert: function(pl.lexer.tokenstream, string, string)
        insert: function(pl.lexer.tokenstream, {pl.lexer.token} | pl.lexer.tokenstream)

        getline: function(pl.lexer.tokenstream): string
        getrest: function(pl.lexer.tokenstream): string
        lineno: function(pl.lexer.tokenstream): number, number
        get_keywords: function(): {string: boolean}

        get_separated_list: function(
            pl.lexer.tokenstream,
            string,
            string
        ): {{pl.lexer.token}}, pl.lexer.token

        skipws: function(pl.lexer.tokenstream): pl.lexer.token
        expecting: function(
            pl.lexer.tokenstream,
            string,
            boolean
        ): pl.lexer.token
    end

    record luabalanced
        match_string: function(string, number): string, number
        match_bracketed: function(string, number): string, number
        match_expression: function(string, number): string, number
        match_namelist: function(string, number): string, number
        match_explist: function(string, number): string, number

        enum snippettype
            'e'
            'c'
            's'
        end
        match_gsub: function(
            string,
            (function(pl.luabalanced.snippettype, string): string)
        ): string
    end

    record operator
        enum OpRepr
            '+'
            '-'
            '*'
            '/'
            '%'
            '^'
            '..'
            '()'
            '[]'
            '<'
            '<='
            '>'
            '>='
            '=='
            '~='
            '#'
            'and'
            'or'
            '{}'
            '~'
            ''
        end

        optable: {pl.operator.OpRepr: function}

        -- TODO properly annotate types as in func
        call: function(function, ...: any): any...
        index: function(table, any): any

        eq: function(any, any): boolean
        neq: function(any, any): boolean
        lt: function(any, any): boolean
        le: function(any, any): boolean
        gt: function(any, any): boolean
        ge: function(any, any): boolean

        len: function(string | table): number

        add: function(number, number): number
        sub: function(number, number): number
        mul: function(number, number): number
        div: function(number, number): number
        pow: function(number, number): number
        mod: function(number, number): number
        unm: function(number): number
        concat: function(string, string): string

        add: function(any, any): any
        sub: function(any, any): any
        mul: function(any, any): any
        div: function(any, any): any
        pow: function(any, any): any
        mod: function(any, any): any
        unm: function(any): any
        concat: function(any, any): any

        lnot: function(any): boolean
        land: function(any, any): boolean
        lor: function(any, any): boolean

        table: function(...: any): {any}
        match: function(string, string): boolean
        nop: function(...: any)
    end

    record path
        is_windows: boolean
        sep: string
        dirsep: string

        dir: function(string): function(): string
        mkdir: function(string): boolean, string
        rmdir: function(string): boolean, string

        currentdir: function(): string
        chdir: function(string): boolean, string

        getsize: function(string): number

        isdir: function(string): boolean
        isfile: function(string): boolean
        isabs: function(string): boolean
        exists: function(string): boolean

        getatime: function(string): number
        getmtime: function(string): number
        getctime: function(string): number

        splitpath: function(string): string, string
        splitext: function(string): string, string

        abspath: function(string, string): string
        dirname: function(string): string
        basename: function(string): string
        extension: function(string): string

        -- 2 mandatory parts
        join: function(string, string, ...: string): string

        normcase: function(string): string
        normpath: function(string): string
        relpath: function(string, string): string
        expanduser: function(string): string

        tmpname: function(): string
        common_prefix: function(string, string): string
        package_path: function(string): string, string

        -- TODO attrib (is there a way to
        -- copy these and functions from lfs.d.tl?)
        -- TODO linkattrib
    end

    record permute
        iter: function({any}): (function(): {any})
        table: function({any}): {{any}}
    end

    record pretty
        read: function(string): table, string
        load: function(string, table, boolean): table, string
        write: function(table, string, boolean): string, string
        dump: function(table, string)
        debug: function(...: any)

        enum PrettyNumberKind
            'N'
            'M'
            'T'
        end
        number: function(number, pl.pretty.PrettyNumberKind, number)
    end

    record seq
        matching: function(string): (function(string): number, number, any...)
        list: function<T>({T}): (function(): T)

        -- TODO check if this is an OK overload
        keys: function(table): (function(): any)
        keys: function<K>({K: any}): (function(): K)

        range: function(number, number): (function(): number)
        minmax: function<T>({T} | function(): T): T, T
        sum: function<T>({T} | function(): T): T, number
        sum: function<T, U>({T} | function(): T, function(T): U): U, number

        copy: function<T>({T} | function(): T): pl.List<T>
        copy2: function<T1, T2, R1, R2>((function(T1, T2): R1, R2), T1, T2): {{R1, R2}}
        copy_tuples: function(function(): any...): {{any}}

        random: function(number, number, number): (function(): number)
        sort: function<T>((function(): T), function(T, T): boolean): (function(): T)
        zip: function<T, U>((function(): T), (function(): U)): (function(): T, U)
        printall: function<T>({T} | function(): T, string, number, function(T): string)

        -- The official documentation is wrong, this only returns 1 value
        count_map: function<T>({T} | function(): T): pl.Map<T, number>

        -- TODO
        map: function<T, U>((function(T): U), {T} | function(): T): (function(): U)
        map: function<T1, T2, U>((function(T1, T2): U), ({T1} | function(): T1), T2): (function(): U)
        map: function<T1, T2, U>((function(T1, T2): U), ({{T1, T2}} | function(): T1, T2)): (function(): U)

        filter: function<T>(({T} | function(): T), (function(T): boolean)): (function(): T)
        filter: function<T, U>(({T} | function(): T), (function(T, U): boolean), U): (function(): T)

        reduce: function<T, R>((function(R, T): R), ({T} | function(): T), R): R
        take: function<T>(({T} | function(): T), number): function(): T
        take: function<T, U>((function(): T, U), number): function(): T, U

        skip: function<T>({T}, number): {T}
        skip: function<T>((function(): T), number): {T}

        enum: function<T>(({T} | function(): T)): function(): number, T
        enum: function<T, U>((function(): T, U)): function(): number, T, U

        -- TODO Is this necessary?
        mapmethod: function(({table} | function(): table), string): function(): any
        mapmethod: function<T>(({table} | function(T): table), string, T): function(): any
        mapmethod: function<T, U>(({table} | function(T, U): table), string, T, U): function(): any

        last: function<T>(({T} | function(): T)): function(): T, T

        foreach: function<T>(({T} | function(): T), (function(T)))

        lines: function(string | FILE, ...: any): function(): any...
    end

    record sip
        enum PatCompileOpt
            'at_start'
        end
        type matcher = function(string, table): boolean

        create_pattern: function(string, {pl.sip.PatCompileOpt: boolean}): string, {string}|string, {any}
        compile: function(string, {pl.sip.PatCompileOpt: boolean}): matcher, {string}|string
        match: function(string, string, table, {PatCompileOpt: boolean}): boolean
        match_at_start: function(string, string, table): boolean
    end

    record strict
        module: function(table): table
        module: function(table, table): table
        module: function(string, table, table): table

        make_all_strict: function(table)

        closed_module: function(table, string)
    end

    record stringio
        record WriteBuffer
            write: function(pl.stringio.WriteBuffer, {string | number})
        end
        record ReadBuffer
            read: function(...: string): any...
        end

        create: function(): pl.stringio.WriteBuffer
        open: function(string): pl.stringio.ReadBuffer
    end

    record stringx
        isalpha: function(string): boolean
        isdigit: function(string): boolean
        isalnum: function(string): boolean
        isspace: function(string): boolean
        islower: function(string): boolean
        isupper: function(string): boolean
        startswith: function(string): boolean
        endswith: function(string): boolean

        join: function(string, {string} | function(): string): string
        splitlines: function(string, boolean): pl.List<string>
        split: function(string, string, string): pl.List<string>
        expandtabs: function(string, number): string

        lfind: function(string, string, number, number): number
        rfind: function(string, string, number, number): number
        replace: function(string, string, string, number): string
        count: function(string, string, boolean): number

        ljust: function(string, number, string): string
        rjust: function(string, number, string): string
        center: function(string, number, string): string
        lstrip: function(string, string): string
        rstrip: function(string, string): string
        strip: function(string, string): string

        splitv: function(string, string): string, string...
        partition: function(string, string): string, string, string
        rpartition: function(string, string): string, string, string
        at: function(string, number): string

        indent: function(string, number, string): string
        dedent: function(string): string

        lines: function(string): function(): string

        title: function(string): string
        shorten: function(string, number, boolean): string
        quote_string: function(string): string
    end

    record tablex
        size: function(table): number

        index_by: function(table, {any}): pl.List<any>
        index_by: function<T, U>({T: U}, {T}): pl.List<T, U>

        -- TODO check if these are OK
        transform: function<T, U>((function(T): U), {any: T})
        transform: function<T, A, U>((function(T, A): U), {any: T}, A)
        transform: function<T, U>((function(T): U), {T})
        transform: function<T, A, U>((function(T, A): U), {T}, A)
        transform: function<A>((function(any, A)), table, A)

        range: function(number, number, number): {number}
        reduce: function<T, R>((function(R, T): R), {T}, R): R
        index_map: function<T, U>({T: U}): {U: T}

        makeset: function<T>({T}): {T: boolean}
        union: function<T>({T: any}, {T: any}): {T: any}
        intersection: function<T>({T: any}, {T: any}): {T: any}
        merge: function<T>({T: any}, {T: any}, boolean): {T: any}
        difference: function<T>({T: any}, {T: any}, boolean): {T: any}

        count_map: function<T>({T}, function(T, T): boolean): {T: number}
        set: function<T>({T}, T, number, number)
        new: function<T>(number, T): {T}
        clear: function<T>({T}, number)

        removevalues: function<T>({T}, number, number)
        readonly: function<T>(table): table

        update: function(table, table): table
        copy: function(table): table
        deepcopy: function(table): table
        icopy: function<T>({T}, {T}, number, number, number)

        insertvalues: function<T>({T}, {T})
        insertvalues: function<T>({T}, number, {T})

        compare: function<T>({T}, {T}, function(T, T): boolean): boolean
        deepcompare: function(table, table, boolean, number): boolean
        compare_no_order: function<T>({T}, {T}, function(T, T): boolean): boolean

        find: function<T>({T}, T, number): number
        rfind: function<T>({T}, T, number): number

        type cmpf = function<T, U>(T, U): boolean
        find_if: function<T, U, R>({T}, cmpf<T, U>, U): number, R

        search: function(table, any, {table}): string

        map: function<K, T, R>((function(T): R), {K: T}): {K: R}
        map: function<K, T, A, R>((function(T, A): R), {K: T}, A): {K: R}

        imap: function<T, R>((function(T): R), {T}): {R}
        imap: function<T, A, R>((function(T, A): R), {T}, A): {R}

        map_named_method: function(string, {table}, ...: any): pl.List<any>

        map2: function<T, U, A, R>((function(T, U, A): R), {any: T}, {any: U}, A): {any: R}
        imap2: function<T, U, A, R>((function(T, U, A): R), {T}, {U}, A): {R}
        mapn: function<T, R>((function(...: T): R), ...: {T}): {R}
        pairmap: function<K, V, R>((function(K, V): R)): {R}

        filter: function<T>({T}, (function(T): boolean)): pl.List<T>
        filter: function<T, A>({T}, (function(T, A): boolean), A): pl.List<T>

        foreach: function<T>({ T }, function(T))
        foreach: function<K, V>((function(V, K)), {K: V})
        foreach: function<K, V, A>((function(V, K, A)), {K: V}, A)
        foreachi: function<V>((function(V, number)), {V})
        foreachi: function<V, A>((function(V, number, A)), {V}, A)

        sort: function<K, V>({K: V}, cmpf): function(): K, V
        sortv: function<K, V>({K: V}, cmpf): function(): K, V

        keys: function({any}): pl.List<number>
        keys: function<K>({K: any}): pl.List<K>
        values: function<V>({any: V}): pl.List<V>
        values: function<V>({V}): pl.List<V>

        sub: function<V>({V}, number, number): pl.List<V>
        zip: function<T>(...: {T}): {{T}}
        zip: function<T1, T2>({T1}, {T2}): {{T1, T2}}
        zip: function<T1, T2, T3>({T1}, {T2}, {T3}): {{T1, T2, T3}}
    end

    record template
        record CompiledTemplate
            render: function(pl.template.CompiledTemplate, table, table, boolean): string
        end

        enum CompileOpt
            'chunk_name'
            'escape'
            'inline_escape'
            'inline_brackets'
            'newline'
            'debug'
        end

        substitute: function(string, table): string, string, string
        compile: function(string, {pl.template.CompileOpt: any}): pl.template.CompiledTemplate, string, string
    end

    record test
        error_handler: function(string, number, string, string, string)
        complain: function(any, any, string, number)
        assertmatch: function(string, string, number)
        assertraise: function(function, string, number)
        asserteq: function(any, any, number, number)
        asserteq2: function(any, any, any, any, number, number)
        tuple: function(...: any): {any}

        timer: function(string, number, function): number
        timer: function<A>(string, number, function(A), A): number
    end

    record text
        format_operator: function

        indent: function(string, number, string): string
        dedent: function(string): string
        wrap: function(string, number): pl.List<string>
        fill: function(string, number): string

        record Template
            -- metamethod __call -- TODO
            substitute: function(pl.text.Template, {string: any}): string
            safe_substitute: function(pl.text.Template, {string: any}): string
            indent_substitute: function(pl.text.Template, {string: any}): string
        end
    end

    record types
        type: function(any): string

        is_type: function(any, any): boolean
        is_callable: function(any): boolean
        is_integer: function(number): boolean
        is_empty: function(any, boolean)
        is_indexable: function(any): boolean
        is_iterable: function(any): boolean
        is_writeable: function(any): boolean

        to_bool: function(any, {string}, boolean): boolean
    end

    record url
        quote: function(string, boolean): string
        unquote: function(string): string
    end

    record utils
        record packedarray<T>
            {T}
            n: number
        end
        pack: function<T>(...: T): pl.utils.packedarray
        unpack: function<T>({T}, number, number)
        printf: function(string, ...: any)
        fprintf: function(FILE, string, ...: any)
        import: function(string | table, table)
        choose: function<T>(boolean, T, T): T

        array_tostring: function<T>({T}, table, function(T, number): string): string
        is_type: function(any, string | metatable): boolean

        enum knownpattern
            'FLOAT'
            'INTEGER'
            'IDEN'
            'FILE'
        end
        patterns: {pl.utils.knownpattern: string}

        enum knownmt
            'List'
            'Map'
            'Set'
            'MultiMap'
        end
        record stdmt_entry
            _name: string
        end

        stdmt: {pl.utils.knownmt: pl.utils.stdmt_entry}

        function_arg: function(number, function | string, string): function
        assert_arg: function<T>(
            number,
            T,
            string | metatable,
            (function(any): boolean),
            string,
            number
        ): T
        assert_string: function<T>(number, T): T

        enum errormode
            'default'
            'error'
            'quit'
        end
        on_error: function(pl.utils.errormode)
        raise: function(string)

        readfile: function(string, boolean): string
        writefile: function(string, string, boolean): boolean, string
        readlines: function(string, boolean): {string}

        executeex: function(string, boolean): boolean, number, string, string
        quote_arg: function(string | {string}): string
        quit: function(string, ...: any)
        quit: function(number, string, ...: any)

        escape: function(string): string
        split: function(string, string, boolean, number): {string}
        splitv: function(string, string): string...

        -- T must be callable, but this should be a good enough compromise
        -- to guarantee function signature remains intact after memoization
        memoize: function<T>(T): T

        add_function_factory: function<T>(metatable, (function(T): function))
        string_lambda: function(string): function(...: any): any...
        bind1: function<T, U, R>((string | function(T, U, ...: any): R), T): function(U, ...: any): R
        bind2: function<T, U, R>((string | function(T, U, ...: any): R), U): function(T, ...: any): R
    end

    record xml

    end
end

return pl