import { ReadCursor, WriteCursor } from './cursor.js'; import { Doc, Path, JSONOp, JSONOpList, Conflict, ConflictType } from './types.js'; export declare const type: { name: string; uri: string; readCursor: (op: JSONOp) => ReadCursor; writeCursor: () => WriteCursor; create(data: Doc): Doc; isNoop(op: JSONOp): boolean; setDebug(val: boolean): void; registerSubtype: typeof registerSubtype; checkValidOp: typeof checkValidOp; normalize: typeof normalize; apply: typeof apply; transformPosition: typeof transformPosition; compose: typeof compose; tryTransform: typeof tryTransform; transform: typeof transform; makeInvertible: typeof makeInvertible; invert: typeof invert; invertWithDoc: typeof invertWithDoc; RM_UNEXPECTED_CONTENT: ConflictType; DROP_COLLISION: ConflictType; BLACKHOLE: ConflictType; transformNoConflict: (op1: JSONOp, op2: JSONOp, side: 'left' | 'right') => JSONOp; typeAllowingConflictsPred: (allowConflict: AllowConflictPred) => { transform(op1: JSONOp, op2: JSONOp, side: 'left' | 'right'): JSONOp; name: string; uri: string; readCursor: (op: JSONOp) => ReadCursor; writeCursor: () => WriteCursor; create(data: Doc): Doc; isNoop(op: JSONOp): boolean; setDebug(val: boolean): void; registerSubtype: typeof registerSubtype; checkValidOp: typeof checkValidOp; normalize: typeof normalize; apply: typeof apply; transformPosition: typeof transformPosition; compose: typeof compose; tryTransform: typeof tryTransform; makeInvertible: typeof makeInvertible; invert: typeof invert; invertWithDoc: typeof invertWithDoc; RM_UNEXPECTED_CONTENT: ConflictType; DROP_COLLISION: ConflictType; BLACKHOLE: ConflictType; transformNoConflict: (op1: JSONOp, op2: JSONOp, side: 'left' | 'right') => JSONOp; typeAllowingConflictsPred: any; }; }; export declare const removeOp: (path: Path, value?: boolean) => JSONOp; export declare const moveOp: (from: Path, to: Path) => JSONOp; export declare const insertOp: (path: Path, value: Doc) => JSONOp; export declare const replaceOp: (path: Path, oldVal: Doc, newVal: Doc) => JSONOp; export declare const editOp: (path: Path, type: Subtype | string, subOp: any, preserveNoop?: boolean) => JSONOp; declare type Subtype = { name: string; uri?: string; apply(doc: any, op: any): any; compose(op1: any, op2: any): any; transform(op1: any, op2: any, by: 'left' | 'right'): any; isNoop?: (op: any) => boolean; invert?: (op: any) => any; makeInvertible?: (op: any, doc: any) => any; [k: string]: any; }; declare function registerSubtype(subtype: Subtype | { type: Subtype; [k: string]: any; }): void; declare function checkValidOp(op: JSONOp): void; declare function normalize(op: JSONOp): JSONOp; /** * Apply op to snapshot. Return the new snapshot. * * The snapshot is shallow copied as its edited, so the previous snapshot * reference is still valid. */ declare function apply(snapshot: Doc | undefined, op: JSONOp): string | number | boolean | Doc[] | { [k: string]: Doc; } | null | undefined; /** * Transforms a path by an operation. Eg: * * ```javascript * newPath = transformPosition([3, 'address'], [2, {r: true}]) * // newPath is [2, 'address'] * ``` * * This is useful for cursors, for tracking annotations and various other * markers which should stick to a single element of the JSON document. * * transformPosition returns null if the item stored at the path no longer * exists in the document after the operation has been applied. Eg: * * ```javascript * assert(transformPosition([2, 'address', 'street'], [2, {r: true}]) === null) * ``` */ declare function transformPosition(path: Path, op: JSONOp): Path | null; declare function compose(op1: JSONOp, op2: JSONOp): JSONOp; /** * Invert the given operation. Operation must be invertible - which is to say, * all removes in the operation must contain all removed content. Note any * operation returned from transform() and compose() will have this content * stripped. * * Unless you know what you're doing, I highly recommend calling invertWithDoc() * instead. */ declare function invert(op: JSONOp): JSONOp; /** * Make an operation invertible. (So, you can call invert(op) after this). * * This is needed because r:XX contents are optional in an operation, and may be * optional in subtypes as well. (Eg text-unicode). * * This method does two main things: * * - Fills in r:{} bodies in components by copying data in from the document * - Recursively calls makeInvertible on any types embedded in the operation. * * Note transform (and compose?) discards remove information, so if you call * transform on an invertible operation you will need to call makeInvertible * again before inverting. */ declare function makeInvertible(op: JSONOp, doc: Doc): JSONOp; /** * Invert the given operation in the context of the passed document. The * specified document must be the document *before* the operation has been * applied. */ declare function invertWithDoc(op: JSONOp, doc: Doc): JSONOp; declare function tryTransform(op1: JSONOp, op2: JSONOp, direction: 'left' | 'right'): { ok: true; result: JSONOp; } | { ok: false; conflict: Conflict; }; declare function transform(op1: JSONOp, op2: JSONOp, side: 'left' | 'right'): JSONOpList | null | undefined; declare type AllowConflictPred = (c: Conflict) => boolean; export {};