@dra2020/baseclient 1.0.13 → 1.0.16

package/dist/context/all.d.ts

@@ -0,0 +1 @@
+export * from './context';

package/dist/context/context.d.ts

@@ -0,0 +1,13 @@
+export declare type ContextValues = {
+    [key: string]: any;
+};
+export interface IContext {
+    setDefaults: (o: ContextValues) => void;
+    setValues: (o: ContextValues) => void;
+    xvalue: (prop: string) => any;
+    xset: (prop: string) => boolean;
+    xflag: (prop: string) => boolean;
+    xnumber: (prop: string) => number;
+    xstring: (prop: string) => string;
+}
+export declare function create(): IContext;

package/dist/filterexpr/all.d.ts

@@ -0,0 +1 @@
+export * from './filterexpr';

package/dist/filterexpr/filterexpr.d.ts

@@ -0,0 +1,67 @@
+import * as Util from '../util/all';
+declare enum TokType {
+    Text = 0,
+    OpenParen = 1,
+    CloseParen = 2,
+    Not = 3,
+    And = 4,
+    Or = 5,
+    Colon = 6,
+    GreaterThan = 7,
+    GreaterThanEqual = 8,
+    Equal = 9,
+    LessThan = 10,
+    LessThanEqual = 11,
+    NotEqual = 12
+}
+interface Token {
+    tt: TokType;
+    text?: string;
+}
+interface Clause {
+    op: Token;
+    operand1?: Clause;
+    operand2?: Clause;
+}
+declare class Lexer {
+    coder: Util.Coder;
+    tokens: Token[];
+    buf: Uint8Array;
+    tok: Uint8Array;
+    toklen: number;
+    n: number;
+    constructor(coder: Util.Coder, expr?: string);
+    set(expr: string): void;
+    pushString(s: string): void;
+    pushText(bForce?: boolean): void;
+    pushSpecial(tt: TokType): void;
+    lex(): void;
+}
+declare class Parser {
+    clauses: Clause[];
+    constructor();
+    get clause(): Clause;
+    initFromTokens(tokens: Token[]): void;
+    initFromClauses(clauses: Clause[]): void;
+    convertOpToText(): void;
+    combineParenthetical(): void;
+    combineUnary(): void;
+    combineColon(): void;
+    combineBinary(tt: TokType): void;
+    combineImplicitAnd(): void;
+    clausesFromTokens(tokens: Token[]): void;
+}
+export declare class FilterExpr {
+    lexer: Lexer;
+    parser: Parser;
+    constructor(coder: Util.Coder, expr?: string);
+    set(expr: string): void;
+    test(o: any, types?: any): boolean;
+    asString(): string;
+    containsClause(expr: string): boolean;
+    addClause(expr: string): void;
+    removeClause(expr: string): void;
+    asStringClause(clause: Clause): string;
+    testClause(o: any, types: any, clause: Clause, prop?: string, relation?: TokType): boolean;
+}
+export {};

package/dist/fsm/all.d.ts

@@ -0,0 +1 @@
+export * from './fsm';

package/dist/fsm/fsm.d.ts

@@ -0,0 +1,119 @@
+import * as Util from '../util/all';
+export declare const FSM_STARTING: number;
+export declare const FSM_PENDING: number;
+export declare const FSM_DONE: number;
+export declare const FSM_ERROR: number;
+export declare const FSM_RELEASED: number;
+export declare const FSM_CUSTOM1: number;
+export declare const FSM_CUSTOM2: number;
+export declare const FSM_CUSTOM3: number;
+export declare const FSM_CUSTOM4: number;
+export declare const FSM_CUSTOM5: number;
+export declare const FSM_CUSTOM6: number;
+export declare const FSM_CUSTOM7: number;
+export declare const FSM_CUSTOM8: number;
+export declare const FSM_CUSTOM9: number;
+export declare type FsmIndex = {
+    [key: number]: Fsm;
+};
+export declare class FsmManager {
+    theId: number;
+    theEpoch: number;
+    bTickSet: boolean;
+    theTickList: FsmIndex;
+    theBusyLoopCount: number;
+    constructor();
+    forceTick(fsm: Fsm): void;
+    doTick(): void;
+}
+export interface FsmEnvironment {
+    fsmManager: FsmManager;
+}
+export declare class Fsm {
+    id: number;
+    state: number;
+    dependentError: boolean;
+    epochDone: number;
+    _env: FsmEnvironment;
+    _waitOn: FsmIndex;
+    _waitedOn: FsmIndex;
+    constructor(env: FsmEnvironment);
+    get env(): FsmEnvironment;
+    get manager(): FsmManager;
+    get done(): boolean;
+    get ready(): boolean;
+    get iserror(): boolean;
+    get isDependentError(): boolean;
+    setDependentError(): void;
+    clearDependentError(): void;
+    get ticked(): boolean;
+    get nWaitOn(): number;
+    get nWaitedOn(): number;
+    waitOn(fsm: Fsm | Fsm[]): Fsm;
+    setState(state: number): void;
+    end(state?: number): void;
+    preTick(): void;
+    tick(): void;
+}
+export declare class FsmOnDone extends Fsm {
+    cb: any;
+    fsm: Fsm | Fsm[];
+    constructor(env: FsmEnvironment, fsm: Fsm | Fsm[], cb: any);
+    tick(): void;
+}
+export declare class FsmSleep extends Fsm {
+    delay: number;
+    timeoutHandle: any;
+    constructor(env: FsmEnvironment, delay: number);
+    tick(): void;
+}
+export declare type SerializerIndex = {
+    [key: string]: Fsm;
+};
+export declare class FsmSerializer extends Fsm {
+    index: SerializerIndex;
+    constructor(env: FsmEnvironment);
+    serialize(id: string, fsm?: Fsm): Fsm;
+    tick(): void;
+}
+declare type FsmArrayMap = {
+    [key: string]: Fsm[];
+};
+export declare class FsmTracker {
+    env: FsmEnvironment;
+    map: FsmArrayMap;
+    constructor(env: FsmEnvironment);
+    _track(uid: string, fsm: Fsm): void;
+    _untrack(uid: string, fsm: Fsm): void;
+    track(uid: string, fsm: Fsm): Fsm;
+    maybeWait(uid: string, fsm: Fsm): void;
+}
+export interface LoopOptions {
+    minRepeatInterval?: number;
+    exitOnError?: boolean;
+}
+export declare const DefaultLoopOptions: {
+    minRepeatInterval: number;
+    exitOnError: boolean;
+};
+export declare class FsmLoop extends Fsm {
+    fsm: Fsm;
+    options: LoopOptions;
+    elapsed: Util.Elapsed;
+    constructor(env: FsmEnvironment, fsm: Fsm, options?: LoopOptions);
+    tick(): void;
+}
+export interface ISet {
+    test: (o: any) => boolean;
+    reset: () => void;
+}
+export declare class FsmArray extends Fsm {
+    a: any[];
+    iset: ISet;
+    constructor(env: FsmEnvironment, iset?: ISet);
+    push(o: any): void;
+    concat(a: any[]): void;
+    splice(i?: number, n?: number): void;
+    reset(): void;
+}
+export {};

package/dist/geo/all.d.ts

@@ -0,0 +1,2 @@
+export * from './geo';
+export * from './vfeature';

package/dist/geo/geo.d.ts

@@ -0,0 +1,67 @@
+import * as geojson from 'geojson';
+import * as Poly from '../poly/all';
+export declare type GeoProperties = geojson.GeoJsonProperties;
+export declare type GeoFeature = geojson.Feature;
+export declare type GeoFeatureArray = GeoFeature[];
+export declare type GeoFeatureCollection = geojson.FeatureCollection;
+export declare function geoCollectionToMap(col: GeoFeatureCollection): GeoFeatureMap;
+export declare function geoMapToCollection(map: GeoFeatureMap): GeoFeatureCollection;
+export declare function geoCollectionToTopo(col: GeoFeatureCollection): Poly.Topo;
+export declare function geoTopoToCollection(topo: Poly.Topo): GeoFeatureCollection;
+export interface GeoFeatureMap {
+    [id: string]: GeoFeature;
+}
+export declare type FeatureFunc = (f: GeoFeature) => void;
+interface GeoEntry {
+    tag: string;
+    col?: GeoFeatureCollection;
+    map?: GeoFeatureMap;
+    topo?: Poly.Topo;
+}
+declare type GeoEntryMap = {
+    [tag: string]: GeoEntry;
+};
+export declare function geoEqual(m1: GeoMultiCollection, m2: GeoMultiCollection): boolean;
+export declare function geoMapEqual(m1: GeoFeatureMap, m2: GeoFeatureMap): boolean;
+export declare class GeoMultiCollection {
+    entries: GeoEntryMap;
+    all: GeoEntry;
+    hidden: any;
+    stamp: number;
+    constructor(tag?: string, topo?: Poly.Topo, col?: GeoFeatureCollection, map?: GeoFeatureMap);
+    empty(): void;
+    get nEntries(): number;
+    nthEntry(n: number): GeoEntry;
+    add(tag: string, topo: Poly.Topo, col: GeoFeatureCollection, map: GeoFeatureMap): void;
+    addMulti(multi: GeoMultiCollection): void;
+    remove(tag: string): void;
+    _onChange(): void;
+    _col(e: GeoEntry): GeoFeatureCollection;
+    _map(e: GeoEntry): GeoFeatureMap;
+    _topo(e: GeoEntry): Poly.Topo;
+    colOf(tag: string): GeoFeatureCollection;
+    mapOf(tag: string): GeoFeatureMap;
+    topoOf(tag: string): Poly.Topo;
+    forEachEntry(cb: (e: GeoEntry) => void): void;
+    allCol(): GeoFeatureCollection;
+    allMap(): GeoFeatureMap;
+    allTopo(): Poly.Topo;
+    hide(id: any): void;
+    show(id: any): void;
+    showAll(): void;
+    get length(): number;
+    nthFeature(n: number): GeoFeature;
+    nthFilteredFeature(n: number, cb: (f: GeoFeature) => boolean): GeoFeature;
+    forEach(cb: FeatureFunc): void;
+    map(cb: (f: GeoFeature) => GeoFeature): GeoFeature[];
+    isHidden(id: string): boolean;
+    find(id: string): GeoFeature;
+    filter(test: (f: GeoFeature) => boolean): GeoMultiCollection;
+}
+export declare enum geoIntersectOptions {
+    Intersects = 0,
+    Bounds = 1,
+    BoundsCenter = 2
+}
+export declare function geoIntersect(multi: GeoMultiCollection, bbox: Poly.BoundBox, opt: geoIntersectOptions): GeoMultiCollection;
+export {};

package/dist/geo/vfeature.d.ts

@@ -0,0 +1,4 @@
+import * as Util from '../util/all';
+import * as Poly from '../poly/all';
+import * as G from './geo';
+export declare function computeVFeature(topoPrecinct: Poly.Topo, bintrie: Util.BinTrie, blocks: string[]): G.GeoFeature;

package/dist/logabstract/all.d.ts

@@ -0,0 +1 @@
+export * from './log';

package/dist/logabstract/log.d.ts

@@ -0,0 +1,26 @@
+import * as Util from '../util/all';
+import * as FSM from '../fsm/all';
+export interface ILog {
+    dump: () => FSM.Fsm;
+    stamp: (o: any) => void;
+    log: (o: any, verbosity?: number) => void;
+    event: (o: any, verbosity?: number) => void;
+    error: (o: any) => void;
+    value: (o: any, verbosity?: number) => void;
+    chatter: (s: string) => void;
+    chatters: () => string[];
+}
+export declare class Timer {
+    ilog: ILog;
+    o: any;
+    verbosity: number;
+    elapsed: Util.Elapsed;
+    constructor(ilog: ILog, kind: string, o: any, verbosity?: number);
+    log(): void;
+}
+export declare class AsyncTimer extends Timer {
+    constructor(ilog: ILog, o: any, verbosity?: number);
+}
+export declare class SyncTimer extends Timer {
+    constructor(ilog: ILog, o: any, verbosity?: number);
+}

package/dist/logclient/all.d.ts

@@ -0,0 +1 @@
+export * from './log';

package/dist/logclient/log.d.ts

@@ -0,0 +1,6 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+export interface LogEnvironment {
+    context: Context.IContext;
+}
+export declare function create(env: LogEnvironment): LogAbstract.ILog;

package/dist/ot-editutil/all.d.ts

@@ -0,0 +1,2 @@
+export * from "./oteditutil";
+export * from "./otmaputil";

package/dist/ot-editutil/oteditutil.d.ts

@@ -0,0 +1,14 @@
+import * as LogAbstract from '../logabstract/all';
+import * as OT from '../ot-js/all';
+export declare class OTEditUtil {
+    ilog: LogAbstract.ILog;
+    resourceID: string;
+    resourceName: string;
+    clientID: string;
+    constructor(ilog: LogAbstract.ILog, rid: string, cid: string, name: string);
+    insertAtStart(s: any, nCurrentLen: number): OT.OTCompositeResource;
+    insertAtEnd(s: any, nCurrentLen: number): OT.OTCompositeResource;
+    injectCursor(edit: OT.OTCompositeResource, start: number, end?: number): void;
+    extractCursor(edit: OT.OTCompositeResource): any;
+    computeEdit(sOld: string, sNew: string): OT.OTCompositeResource;
+}

package/dist/ot-editutil/otmaputil.d.ts

@@ -0,0 +1,21 @@
+import * as OT from '../ot-js/all';
+export declare const MERGE: number;
+export declare const REPLACE: number;
+export declare class Editor {
+    private engine;
+    private root;
+    private stamps;
+    constructor(engine: OT.OTEngine);
+    startLocalEdit(): void;
+    stamp(rid: string, prop: string): void;
+    set(rid: string, p: string, v: any): Editor;
+    del(rid: string, p: string): Editor;
+    rawObject(rid: string): OT.OTMapResource;
+    rawArray(rid: string): OT.OTArrayResource;
+    editCounter(rid: string, oNew: any, mode?: number): void;
+    editObject(rid: string, oNew: any, mode?: number): void;
+    editArray(rid: string, aNew: any[]): void;
+    edit(oNew: any): boolean;
+    get length(): number;
+    commit(): boolean;
+}

package/dist/ot-js/all.d.ts

@@ -0,0 +1,9 @@
+export * from "./otarray";
+export * from "./otengine";
+export * from "./otclientengine";
+export * from "./otcomposite";
+export * from "./otmap";
+export * from "./otcounter";
+export * from "./otserverengine";
+export * from "./ottypes";
+export * from "./otsession";

package/dist/ot-js/otarray.d.ts

@@ -0,0 +1,111 @@
+import * as OT from "./ottypes";
+export declare const OpInsert: number;
+export declare const OpDelete: number;
+export declare const OpRetain: number;
+export declare const OpCursor: number;
+export declare const OpSet: number;
+export declare const OpTmpRetain: number;
+export declare type OTSingleArrayEdit = [number, number, any];
+export declare type OTEdits = OTSingleArrayEdit[];
+declare enum OTalignEdgesType {
+    AlignForCompose = 0,
+    AlignForTransform = 1
+}
+export interface IOTArrayLikeOperations {
+    underlyingTypeName(): string;
+    empty(): any;
+    insert(t: any, pos: number, tInsert: any): any;
+    delete(t: any, pos: number, len: number): any;
+    set(t: any, pos: number, tSet: any): any;
+    append(t: any, tAppend: any): any;
+    substr(t: any, pos: number, len: number): any;
+    substrOf(t: any, pos: number, len: number, tsub: any): any;
+    constructN(n: number): any;
+    equal(t1: any, t2: any): boolean;
+    copy(t: any): any;
+    length(t: any): number;
+}
+export declare class OTSingleArrayEditor {
+    raw: IOTArrayLikeOperations;
+    constructor(raw: IOTArrayLikeOperations);
+    copy(a: OTSingleArrayEdit): OTSingleArrayEdit;
+    isDelete(a: OTSingleArrayEdit): boolean;
+    isNotDelete(a: OTSingleArrayEdit): boolean;
+    isCursor(a: OTSingleArrayEdit): boolean;
+    isNotCursor(a: OTSingleArrayEdit): boolean;
+    isTmpRetain(a: OTSingleArrayEdit): boolean;
+    isNotTmpRetainOrDelete(a: OTSingleArrayEdit): boolean;
+    isTmpRetainOrDelete(a: OTSingleArrayEdit): boolean;
+    isIgnore(a: OTSingleArrayEdit): boolean;
+    isNoOp(a: OTSingleArrayEdit): boolean;
+    isEqual(a1: OTSingleArrayEdit, a2: OTSingleArrayEdit): boolean;
+    appendValue(a: OTSingleArrayEdit, s: any): void;
+    empty(a: OTSingleArrayEdit): void;
+    setIgnore(a: OTSingleArrayEdit): void;
+    substr(aIn: OTSingleArrayEdit, pos: number, len: number): void;
+    substrFromRaw(aIn: OTSingleArrayEdit, pos: number, len: number, s: any): void;
+    copyWithSubstr(aIn: OTSingleArrayEdit, pos: number, len: number): OTSingleArrayEdit;
+}
+export declare class OTStringOperations implements IOTArrayLikeOperations {
+    underlyingTypeName(): string;
+    empty(): any;
+    insert(a: any, pos: number, aInsert: any): any;
+    delete(a: any, pos: number, len: number): any;
+    set(a: any, pos: number, aSet: any): any;
+    append(a: any, aAppend: any): any;
+    substr(a: any, pos: number, len: number): any;
+    substrOf(a: any, pos: number, len: number, aSub: any): any;
+    constructN(n: number): any;
+    equal(a1: any, a2: any): boolean;
+    copy(a: any): any;
+    length(a: any): number;
+}
+export declare class OTArrayOperations implements IOTArrayLikeOperations {
+    underlyingTypeName(): string;
+    empty(): any;
+    insert(a: any, pos: number, aInsert: any): any;
+    delete(a: any, pos: number, len: number): any;
+    set(a: any, pos: number, aSet: any): any;
+    append(a: any, aAppend: any): any;
+    substr(a: any, pos: number, len: number): any;
+    substrOf(a: any, pos: number, len: number, aSub: any): any;
+    constructN(n: number): any;
+    equal(a1: any, a2: any): boolean;
+    copy(a: any): any;
+    length(a: any): number;
+}
+export declare class OTArrayLikeResource extends OT.OTResourceBase {
+    editor: OTSingleArrayEditor;
+    constructor(ed: OTSingleArrayEditor, rname: string);
+    copy(): OTArrayLikeResource;
+    moveEdits(newA: OTEdits, iStart: number, iEnd?: number, pred?: (a: OTSingleArrayEdit) => boolean): void;
+    equal(rhs: OTArrayLikeResource): boolean;
+    effectivelyEqual(rhs: OTArrayLikeResource): boolean;
+    basesConsistent(rhs: OTArrayLikeResource): void;
+    originalLength(): number;
+    finalLength(): number;
+    apply(aValue: any): any;
+    coalesce(bDeleteCursor?: boolean): void;
+    fullyCoalesce(): void;
+    invert(sInput: any): void;
+    alignEdges(rhs: OTArrayLikeResource, st: OTalignEdgesType): void;
+    getCursorCache(): any;
+    compose(rhs: OTArrayLikeResource): void;
+    performTransformReorder(bForceRetainBeforeInsert: boolean, newA: OTEdits, iBegin: number, iEnd: number): void;
+    normalizeNewRetainsAfterTransform(bForceRetainBeforeInsert: boolean): void;
+    transform(prior: OTArrayLikeResource, bPriorIsService: boolean): void;
+    generateRandom(nInitial: number, clientID: string): void;
+}
+export declare class OTStringResource extends OTArrayLikeResource {
+    static _editor: OTSingleArrayEditor;
+    constructor(rname: string);
+    static factory(rname: string): OTStringResource;
+    copy(): OTStringResource;
+}
+export declare class OTArrayResource extends OTArrayLikeResource {
+    static _editor: OTSingleArrayEditor;
+    constructor(rname: string);
+    static factory(rname: string): OTArrayResource;
+    copy(): OTArrayResource;
+}
+export {};

package/dist/ot-js/otclientengine.d.ts

@@ -0,0 +1,38 @@
+import * as LogAbstract from "../logabstract/all";
+import * as OTC from "./otcomposite";
+import * as OTE from "./otengine";
+export declare class OTClientEngine extends OTE.OTEngine {
+    clientID: string;
+    resourceID: string;
+    isNeedAck: boolean;
+    isNeedResend: boolean;
+    bReadOnly: boolean;
+    clientSequenceNo: number;
+    stateServer: OTC.OTCompositeResource;
+    stateLocal: OTC.OTCompositeResource;
+    valCache: any;
+    prefailCache: any;
+    actionAllClient: OTC.OTCompositeResource;
+    actionAllPendingClient: OTC.OTCompositeResource;
+    actionSentClient: OTC.OTCompositeResource;
+    actionSentClientOriginal: OTC.OTCompositeResource;
+    actionServerInterposedSentClient: OTC.OTCompositeResource;
+    constructor(ilog: LogAbstract.ILog, rid: string, cid: string);
+    initialize(): void;
+    serverClock(): number;
+    rid(): string;
+    cid(): string;
+    toPartialValue(resourceName: string): any;
+    toValue(): any;
+    toPrefailValue(): any;
+    clearPrefail(): void;
+    setReadOnly(b: boolean): void;
+    startLocalEdit(): OTC.OTCompositeResource;
+    isPending(): boolean;
+    getPending(): OTC.OTCompositeResource;
+    resetPending(): void;
+    failbackToInitialState(): void;
+    failbackToServerState(): void;
+    addRemote(orig: OTC.OTCompositeResource): void;
+    addLocalEdit(orig: OTC.OTCompositeResource): void;
+}

package/dist/ot-js/otcomposite.d.ts

@@ -0,0 +1,37 @@
+import * as OT from "./ottypes";
+import * as OTA from "./otarray";
+import * as OTM from "./otmap";
+import * as OTC from "./otcounter";
+export declare const clockInitialValue: number;
+export declare const clockTerminateValue: number;
+export declare const clockRandomizeValue: number;
+export declare const clockFailureValue: number;
+export declare const clockInitializeValue: number;
+export declare const clockUndoValue: number;
+export declare const clockSeenValue: number;
+export declare class OTCompositeResource extends OT.OTResourceBase {
+    resourceID: string;
+    clientID: string;
+    clock: number;
+    clientSequenceNo: number;
+    static typeRegistry: any;
+    constructor(rid: string, cid: string);
+    static registerType(underlyingType: string, factory: (resourceName: string) => OT.OTResourceBase): void;
+    findResource(rname: string, utype?: string, bConstruct?: boolean): OT.IOTResource;
+    map(rid: string): OTM.OTMapResource;
+    array(rid: string): OTA.OTArrayResource;
+    counter(rid: string): OTC.OTCounterResource;
+    garbageCollect(map: any): boolean;
+    isEmpty(): boolean;
+    copy(): OTCompositeResource;
+    effectivelyEqual(rhs: OTCompositeResource): boolean;
+    transform(rhs: OTCompositeResource, bPriorIsService: boolean): void;
+    compose(rhs: OTCompositeResource): void;
+    apply(runningValue: any): any;
+    toPartialValue(resourceName: string): any;
+    toValue(): any;
+    minimize(): void;
+    static constructResource(rname: string, utype: string): OT.IOTResource;
+    static constructFromObject(o: any): OTCompositeResource;
+    toJSON(): any;
+}

package/dist/ot-js/otcounter.d.ts

@@ -0,0 +1,17 @@
+import * as OT from "./ottypes";
+export declare const OpCounterAdd = 1;
+export declare const OpCounterDel = 2;
+export declare type CounterEdit = [number, string, any];
+export declare class OTCounterResource extends OT.OTResourceBase {
+    constructor(rid: string);
+    static factory(rid: string): OTCounterResource;
+    copy(): OTCounterResource;
+    effectivelyEqual(rhs: OTCounterResource): boolean;
+    transform(prior: OTCounterResource, bPriorIsService: boolean): void;
+    compose(rhs: OTCounterResource): void;
+    apply(startValue: any): any;
+    minimize(): any;
+    loadObject(o: any): any;
+    toObject(): any;
+    fromObject(o: any): void;
+}

package/dist/ot-js/otengine.d.ts

@@ -0,0 +1,22 @@
+import * as LogAbstract from "../logabstract/all";
+import * as OTC from "./otcomposite";
+export interface IOTEngine {
+    cid(): string;
+    rid(): string;
+    toPartialValue(resourceName: string): any;
+    startLocalEdit(): OTC.OTCompositeResource;
+    addLocalEdit(e: OTC.OTCompositeResource): void;
+}
+export declare class OTEngine implements IOTEngine {
+    ilog: LogAbstract.ILog;
+    onList: any;
+    constructor(ilog: LogAbstract.ILog);
+    on(eventName: string, cb: any): void;
+    off(eventName: string, cb: any): void;
+    emit(eventName: string): void;
+    cid(): string;
+    rid(): string;
+    toPartialValue(resourceName: string): any;
+    startLocalEdit(): OTC.OTCompositeResource;
+    addLocalEdit(e: OTC.OTCompositeResource): void;
+}

package/dist/ot-js/otmap.d.ts

@@ -0,0 +1,19 @@
+import * as OT from './ottypes';
+export declare const OpMapSet = 1;
+export declare const OpMapDel = 2;
+export declare type MapEdit = [number, string, any];
+export declare class OTMapResource extends OT.OTResourceBase {
+    constructor(rid: string);
+    static factory(rid: string): OTMapResource;
+    set(p: string, a: any): OTMapResource;
+    del(p: string): OTMapResource;
+    copy(): OTMapResource;
+    effectivelyEqual(rhs: OTMapResource): boolean;
+    transform(prior: OTMapResource, bPriorIsService: boolean): void;
+    compose(rhs: OTMapResource): void;
+    apply(startValue: any): any;
+    minimize(): any;
+    loadObject(o: any): any;
+    toObject(): any;
+    fromObject(o: any): void;
+}

package/dist/ot-js/otserverengine.d.ts

@@ -0,0 +1,38 @@
+import * as LogAbstract from '../logabstract/all';
+import * as OTC from "./otcomposite";
+import * as OTE from "./otengine";
+export declare const ClientIDForServer: string;
+export declare class OTServerEngine extends OTE.OTEngine {
+    stateServer: OTC.OTCompositeResource;
+    logServer: OTC.OTCompositeResource[];
+    valCache: any;
+    fullCache: any;
+    highSequence: any;
+    clientSequenceNo: number;
+    constructor(ilog: LogAbstract.ILog, rid: string);
+    serverClock(): number;
+    rid(): string;
+    cid(): string;
+    startLocalEdit(): OTC.OTCompositeResource;
+    resetCaches(): void;
+    toPartialValue(resourceName: string): any;
+    toValue(): any;
+    getProp(s: string): any;
+    getName(): string;
+    getType(): string;
+    getDescription(): string;
+    getCreatedBy(): string;
+    getCreateTime(): string;
+    getCreatedByName(): string;
+    hasSeenEvent(orig: OTC.OTCompositeResource): boolean;
+    isNextEvent(orig: OTC.OTCompositeResource): boolean;
+    rememberSeenEvent(orig: OTC.OTCompositeResource): void;
+    forgetEvents(orig: OTC.OTCompositeResource): void;
+    clientHighSequence(cid: string): number;
+    garbageCollect(): void;
+    addServer(orig: OTC.OTCompositeResource): number;
+    addLocalEdit(orig: OTC.OTCompositeResource): void;
+    toJSON(): any;
+    validateLog(): void;
+    loadFromObject(o: any): void;
+}