S8 implements a string whose offsets are UTF8 bytes

S16 implements string with offsets and counts referring to utf16 runes. The UTF16 offsets map to native Javascript string offsets.

Path represents a reference to a value at a specific path. A nil or empty path refers to the root value. This is an immutable type -- none of the met

Counter implements a 32-bit counter that can be incremented, decremented or replaced. Counter implements the changes.Value interface.

ChangeSet represents a collection of changes. It implements the Change interface thereby allowing merging groups of changes against each other.

Callable wraps a function into a value type that can be called

FontWeight is CSS font-weight

MySlice is public

MySliceP is public

Scope is any scope lookup function. Scope lookups are expected to return evaluated values but nested fields may contain unevaluated values.

Slice has the type information of a slice for code generation of the Apply(), ApplyCollection() and Splice() methods

TodoList tracks a collection of todo items

The A type represents a slice of arbitrary values. It implements the changes.Value interface. The actual elements can be nil (unlike the regular requi

Change represents an OT-compatible mutation The methods provided here are the core methods. Custom changes should implement the Custom interface in

NoAttribute specified that a specific attribute should be nullified. This is used with Editor.SetAttribute to specify that the override is actively re

SliceStream implements code generation for streams of slices

StructStream implements code generation for streams of structs

UnionStream implements stream functionality for unions

Text represents a rich text

Value represents an immutable JSON object that can apply changes. Array like values should also implement Collection

Atomic is an atomic Value. It can wrap any particular value and can be used in the Before, After fields of Replace or Splice.

Attr is a single attribute value

Attrs is a collection of attribute name value pairs

BlockQuote represents a block quote with any embedded content

Bolt represents a local file (bolt db) storage Path is the path to the file to write snapshots Initial is the initial app state. This can be nil if

Bool implements a bool stream.

Cache holds transformation state for each operation. The transformed op is a version of the original op but one which can be applied directly on top

Call represents a "call" expression. The first element of the array is expected to be "Callable" which can be called with the rest as args. All error

Caret is a reference to a specific position in an array-like object. This is an immutable type This only handles the standard set of changes. Custom

Client implements the ops.Store interface by making network calls to the provided Url. All other fields of the Client are optional.

Client implements the ops.Store interface by making network calls to the provided Url. All other fields of the Client are optional.

Codec is the interface codecs will have to implement to marshal and unmarshal requests and responses

Codec exposes both the encoder and decoder

Col represents the information about the column. The ID field is immutable. The Ord field is meant to help sort the columns and is not meant to be d

Collection represents an immutable array-like value

Cols represents all the columns in the table

Config defines the configuration options for synchronization

Container holds a single CRDT value. This is implemented as a map of unique rank to values. Every update creates a new entry in this map. Undo of an

Container wraps a Value and a set of references into the value. It implements the changes.Value interface. It acts like a "map-like" object with the

Context defines the context in which a change is being applied. This is useful to capture data such as the "current user" or "virtual time" etc. For

Counter implements a counter stream.

Custom is the interface that custom change types should implement. This allows the "known" types to interact with custom types. Custom changes might

Decoder decodes any value

Dict implements a CRDT-style dictionary

Differ is the general Diff interface for computing changes in values as a changes.Change (which when applied to the old value is guaranteed to result

Dir wraps a value along with a map of objects. The contents of the value can refer to entries in the map using Ref

Editor wraps rich.Text with selection state and richer APIs The current cursor position is stored in Focus and Achor, both of which must have atleast

Encoder encodes any value

Entry is a heap entry

Field holds info for a struct field

FontStyle is CSS font-style

Formatter is a generic html formatter

Generic is a helper to build value and collection types

Handler implements ServerHTTP using the provided store and codecs map. If no codecs map is provided, DefaultCodecs is used instead.

Heading represents h1 to h6. Note that the contents of the heading tag can be any rich text.

Heap implements a heap of keys

Image represents an image url

Info tracks all information used for code generation

Int implements an int stream.

Link represents a url link

List represents an ordered or unordered list The type can be one of the string values defined here: https://developer.mozilla.org/en-US/docs/Web/CSS/

Log is the default interface for logging used through out the DOT project. This allows callers to provide their implementation if needed.

The M type represents a map of arbitrary key/values. It implements the changes.Value interface. As with all values, a nil value should be expressed v

MergeResult contains the result of calling Merge on a path. If the path is invalidated by the change, the whole result is nil. Otherwise the field P s

Meta wraps a change with some metadata that is maintained as the change is merged. This is useful for carrying contexts with changes. One example is t

Move represents a shuffling of some elements (specified by Offset and Count) over to a different spot (specified by Distance, which can be negative t

MySlicePStream implements a stream of *MySliceP values

MySliceStream implements a stream of MySlice values

MyStruct is public

MyStructStream implements a stream of MyStruct values

Op represents a collection of changes, like a git-commit. The ID of the op uniquely identifies it. All operations are effectively ordered sequentual

Operation holds the basic info needed for Op with string IDs

Option can be used to configure Sync behavior See WithSession and WithCloseNotify

ParseError captures the error state

PathChange represents a change at the provided "path" which can consist of strings (for map-like objects) and integers for array-like objects. In part

PathMerger is the interface that custom Change types should implement.

Range is a reference to a specific selection of elements in an array-like object. Ranges can be "collapsed" when they behave the same as Caret. This

Rank implements a unique ID that can be used for sorting. The Epoch field is meant to track the time when the rank was created, so this can be used f

Ref represents the core Reference type

Ref represents a refereence to an embedded object storeed in a Dir. The Dir must be an ancestor of the Ref

Replace represents create, delete and update of a value based on whether Before is Nil, After is Nil and both are non-Nil respectively.

Row represents the information about a row The ID field is immutable. The Ord field is meant to help sort the rows and is not meant to be directly m

Rows represents all the rows in the table

Run implements a custom change type which applies a provided inner change to a run of items in an array. This is particularly useful for rich text op

S16 implements an UFT16 string stream

S8 implements an UFT8 string stream