jazz-tools

CoValues

type ID

type ID<T> = CojsonInternalTypes.RawCoID & IDMarker<T>

⚠️ undocumented

class CoMap

CoMaps are collaborative versions of plain objects, mapping string-like keys to values.
Declaration
Declare your own CoMap schemas by subclassing CoMap and assigning field schemas with co.

Optional co.ref(...) fields must be marked with { optional: true }.

Example:
import { co, CoMap } from "jazz-tools";

class Person extends CoMap {
  name = co.string;
  age = co.number;
  pet = co.ref(Animal);
  car = co.ref(Car, { optional: true });
}
CoMap.Record<Value>(value): RecordLikeCoMap
value: IfCo<Value, Value>
Declare a Record-like CoMap schema, by extending CoMap.Record(...) and passing the value schema using co. Keys are always string.
Example:
import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
 co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;
Content
You can access properties you declare on a CoMap (using co) as if they were normal properties on a plain object, using dot notation, Object.keys(), etc.

Example:
person.name;
person["age"];
person.age = 42;
person.pet?.name;
Object.keys(person);
// => ["name", "age", "pet"]
.id: ID<CoMap>
The ID of this CoMap
._refs: {[Key in string]: IfCo<this[Key], RefIfCoValue<this[Key]>>}
If property prop is a co.ref(...), you can use coMaps._refs.prop to access
the Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example:
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
Creation
CoMap.create<M>(init, options): M
M extends CoMap
this: CoValueClass<M>,
init: Simplify<CoMapInit<M>>,
options: { owner: Group | Account, unique: JsonValue }
Create a new CoMap with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoMap will immediately be persisted and synced to connected peers.
Example:
const person = Person.create({
  name: "Alice",
  age: 42,
  pet: cat,
}, { owner: friendGroup });
Subscription & Loading
CoMap.load<M, Depth>(id, as, depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: CoValueClass<M>,
id: ID<M>,
as: Account,
depth: Depth & DepthsIn<M>
Load a CoMap with a given ID, as a given account.

depth specifies which (if any) fields that reference other CoValues to load as well before resolving.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.
Example:
const person = await Person.load(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { pet: {} }
);
CoMap.subscribe<M, Depth>(id, as, depth, listener): () => void
M extends CoMap
this: CoValueClass<M>,
id: ID<M>,
as: Account,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Load and subscribe to a CoMap with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies which (if any) fields that reference other CoValues to load as well before calling listener for the first time.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the useCoState hook to reactively subscribe to a CoValue in a React component.
Example:
const unsub = Person.subscribe(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { pet: {} },
  (person) => console.log(person)
);
.ensureLoaded<M, Depth>(depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>
Given an already loaded CoMap, ensure that the specified fields are loaded to the specified depth.

Works like CoMap.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<M, Depth>(depth, listener): () => void
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Given an already loaded CoMap, subscribe to updates to the CoMap and ensure that the specified fields are loaded to the specified depth.

Works like CoMap.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
Collaboration
._edits: {[Key in string]: IfCo<this[Key], CoMapEdit<this[Key]>>}
⚠️ undocumented
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
⚠️ undocumented
.[inspect](): any[]
⚠️ undocumented
Internals
CoMap.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoMap<{ undefined }, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoMap"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
CoMap.findUnique<M>(unique, ownerID, as): ID<M>
M extends CoMap
this: CoValueClass<M>,
unique: JsonValue,
ownerID: ID<Group> | ID<Account>,
as: AnonymousJazzAgent | Group | Account
⚠️ undocumented
.applyDiff<N>(newValues): CoMap
N extends Partial<CoMapInit<CoMap>>
newValues: N
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

class CoList<Item>

CoLists are collaborative versions of plain arrays.

*
Declaration
CoList.Of<Item>(item): CoList
item: Item
Declare a CoList by subclassing CoList.Of(...) and passing the item schema using co.
Example:
class ColorList extends CoList.Of(
  co.string
) {}
class AnimalList extends CoList.Of(
  co.ref(Animal)
) {}
Content
You can access items on a CoList as if they were normal items on a plain array, using [] notation, etc.

Since CoList is a subclass of Array, you can use all the normal array methods like push, pop, splice, etc.

Example:
colorList[0];
colorList[3] = "yellow";
colorList.push("Kawazaki Green");
colorList.splice(1, 1);
.id: ID<CoList<Item>>
The ID of this CoList
._refs: { undefined } & { length: number, [iterator]: NO TYPE }
If a CoList's items are a co.ref(...), you can use coList._refs[i] to access
the Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example:
animals._refs[0].id; // => ID<Animal>
animals._refs[0].value;
// => Animal | null
const animal = await animals._refs[0].load();
Creation
CoList.create<L>(items, options): L
L extends CoList<any>
this: CoValueClass<L>,
items: UnCo<L[number]>[],
options: { owner: Group | Account }
Create a new CoList with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoList will immediately be persisted and synced to connected peers.
Example:
const colours = ColorList.create(
  ["red", "green", "blue"],
  { owner: me }
);
const animals = AnimalList.create(
  [cat, dog, fish],
  { owner: me }
);
Subscription & Loading
CoList.load<L, Depth>(id, as, depth): Promise<DeeplyLoaded<L, Depth> | undefined>
L extends CoList<any>
this: CoValueClass<L>,
id: ID<L>,
as: Account,
depth: Depth & DepthsIn<L>
Load a CoList with a given ID, as a given account.

depth specifies if item CoValue references should be loaded as well before resolving.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or for shallowly loading only this CoList, or [itemDepth] for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.
Example:
const animalsWithVets =
  await ListOfAnimals.load(
    "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
    me,
    [{ vet: {} }]
  );
CoList.subscribe<L, Depth>(id, as, depth, listener): () => void
L extends CoList<any>
this: CoValueClass<L>,
id: ID<L>,
as: Account,
depth: Depth & DepthsIn<L>,
listener: (value: DeeplyLoaded<L, Depth>) => void
Load and subscribe to a CoList with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies if item CoValue references should be loaded as well before calling listener for the first time.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or for shallowly loading only this CoList, or [itemDepth] for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the useCoState hook to reactively subscribe to a CoValue in a React component.
Example:
const unsub = ListOfAnimals.subscribe(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { vet: {} },
  (animalsWithVets) => console.log(animalsWithVets)
);
.ensureLoaded<L, Depth>(depth): Promise<DeeplyLoaded<L, Depth> | undefined>
L extends CoList<any>
this: L,
depth: Depth & DepthsIn<L>
Given an already loaded CoList, ensure that items are loaded to the specified depth.

Works like CoList.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<L, Depth>(depth, listener): () => void
L extends CoList<any>
this: L,
depth: Depth & DepthsIn<L>,
listener: (value: DeeplyLoaded<L, Depth>) => void
Given an already loaded CoList, subscribe to updates to the CoList and ensure that items are loaded to the specified depth.

Works like CoList.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
⚠️ undocumented
.[inspect](): any[]
⚠️ undocumented
Internals
CoList.fromRaw<V>(raw): V & CoList<any>
V extends CoList<any>
this: CoValueClass<V> & CoList,
raw: RawCoList<JsonValue, JsonObject | null>
⚠️ undocumented
._raw: RawCoList<JsonValue, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoList"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
CoList[species]: ArrayConstructor
⚠️ undocumented
CoList.isArray(arg): arg is any[]
arg: any
⚠️ undocumented
CoList.from<T>(arrayLike): T[]
arrayLike: ArrayLike<T>
Creates an array from an array-like object.
CoList.from<T, U>(arrayLike, mapfn, thisArg): U[]
arrayLike: ArrayLike<T>,
mapfn: (v: T, k: number) => U,
thisArg: any
Creates an array from an iterable object.
CoList.from<T>(iterable): T[]
iterable: ArrayLike<T> | Iterable<T>
Creates an array from an iterable object.
CoList.from<T, U>(iterable, mapfn, thisArg): U[]
iterable: ArrayLike<T> | Iterable<T>,
mapfn: (v: T, k: number) => U,
thisArg: any
Creates an array from an iterable object.
.constructor: NO TYPE
⚠️ undocumented
._edits: { undefined }
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
.push(items): number
items: Item[]
⚠️ undocumented
.unshift(items): number
items: Item[]
⚠️ undocumented
.pop(): Item | undefined
⚠️ undocumented
.shift(): Item | undefined
⚠️ undocumented
.splice(start, deleteCount, items): Item[]
start: number,
deleteCount: number,
items: Item[]
⚠️ undocumented
.length: number
Gets or sets the length of the array. This is a number one higher than the highest index in the array.
.toString(): string
Returns a string representation of an array.
.toLocaleString(): string
Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
.concat(items): Item[]
items: ConcatArray<Item>[]
Combines two or more arrays.
This method returns a new array without modifying any existing arrays.
.concat(items): Item[]
items: ConcatArray<Item> | Item[]
Combines two or more arrays.
This method returns a new array without modifying any existing arrays.
.join(separator): string
separator: string
Adds all the elements of an array into a string, separated by the specified separator string.
.reverse(): Item[]
Reverses the elements in an array in place.
This method mutates the array and returns a reference to the same array.
.slice(start, end): Item[]
start: number,
end: number
Returns a copy of a section of an array.
For both start and end, a negative index can be used to indicate an offset from the end of the array.
For example, -2 refers to the second to last element of the array.
.sort(compareFn): this
compareFn: (a: Item, b: Item) => number
Sorts an array in place.
This method mutates the array and returns a reference to the same array.
.indexOf(searchElement, fromIndex): number
searchElement: Item,
fromIndex: number
Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
.lastIndexOf(searchElement, fromIndex): number
searchElement: Item,
fromIndex: number
Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.
.every<S>(predicate, thisArg): this is S[]
predicate: (value: Item, index: number, array: Item[]) => value is S,
thisArg: any
Determines whether all the members of an array satisfy the specified test.
.every(predicate, thisArg): boolean
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Determines whether all the members of an array satisfy the specified test.
.some(predicate, thisArg): boolean
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Determines whether the specified callback function returns true for any element of an array.
.forEach(callbackfn, thisArg): void
callbackfn: (value: Item, index: number, array: Item[]) => void,
thisArg: any
Performs the specified action for each element in an array.
.map<U>(callbackfn, thisArg): U[]
callbackfn: (value: Item, index: number, array: Item[]) => U,
thisArg: any
Calls a defined callback function on each element of an array, and returns an array that contains the results.
.filter<S>(predicate, thisArg): S[]
predicate: (value: Item, index: number, array: Item[]) => value is S,
thisArg: any
Returns the elements of an array that meet the condition specified in a callback function.
.filter(predicate, thisArg): Item[]
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Returns the elements of an array that meet the condition specified in a callback function.
.reduce(callbackfn): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.reduce(callbackfn, initialValue): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item,
initialValue: Item
⚠️ undocumented
.reduce<U>(callbackfn, initialValue): U
callbackfn: (previousValue: U, currentValue: Item, currentIndex: number, array: Item[]) => U,
initialValue: U
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.reduceRight(callbackfn): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item
Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.reduceRight(callbackfn, initialValue): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item,
initialValue: Item
⚠️ undocumented
.reduceRight<U>(callbackfn, initialValue): U
callbackfn: (previousValue: U, currentValue: Item, currentIndex: number, array: Item[]) => U,
initialValue: U
Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.find<S>(predicate, thisArg): S | undefined
predicate: (value: Item, index: number, obj: Item[]) => value is S,
thisArg: any
Returns the value of the first element in the array where predicate is true, and undefined
otherwise.
.find(predicate, thisArg): Item | undefined
predicate: (value: Item, index: number, obj: Item[]) => unknown,
thisArg: any
⚠️ undocumented
.findIndex(predicate, thisArg): number
predicate: (value: Item, index: number, obj: Item[]) => unknown,
thisArg: any
Returns the index of the first element in the array where predicate is true, and -1
otherwise.
.fill(value, start, end): this
value: Item,
start: number,
end: number
Changes all array elements from start to end index to a static value and returns the modified array
.copyWithin(target, start, end): this
target: number,
start: number,
end: number
Returns the this object after copying a section of the array identified by start and end
to the same array starting at position target
.entries(): IterableIterator<[number, Item]>
Returns an iterable of key, value pairs for every entry in the array
.keys(): IterableIterator<number>
Returns an iterable of keys in the array
.values(): IterableIterator<Item>
Returns an iterable of values in the array
.includes(searchElement, fromIndex): boolean
searchElement: Item,
fromIndex: number
Determines whether an array includes a certain element, returning true or false as appropriate.
.flatMap<U, This>(callback, thisArg): U[]
callback: (this: This, value: Item, index: number, array: Item[]) => TODO type typeOperator | U,
thisArg: This
Calls a defined callback function on each element of an array. Then, flattens the result into
a new array.
This is identical to a map followed by flat with depth 1.
.flat<A, D>(depth): FlatArray<A, D>[]
D extends number
this: A,
depth: D
Returns a new array with all sub-array elements concatenated into it recursively up to the
specified depth.
.at(index): Item | undefined
index: number
Returns the item located at the specified index.
.findLast<S>(predicate, thisArg): S | undefined
predicate: (value: Item, index: number, array: Item[]) => value is S,
thisArg: any
Returns the value of the last element in the array where predicate is true, and undefined
otherwise.
.findLast(predicate, thisArg): Item | undefined
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
⚠️ undocumented
.findLastIndex(predicate, thisArg): number
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Returns the index of the last element in the array where predicate is true, and -1
otherwise.
.toReversed(): Item[]
Returns a copy of an array with its elements reversed.
.toSorted(compareFn): Item[]
compareFn: (a: Item, b: Item) => number
Returns a copy of an array with its elements sorted.
.toSpliced(start, deleteCount, items): Item[]
start: number,
deleteCount: number,
items: Item[]
Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.
.toSpliced(start, deleteCount): Item[]
start: number,
deleteCount: number
Copies an array and removes elements while returning the remaining elements.
.with(index, value): Item[]
index: number,
value: Item
Copies an array, then overwrites the value at the provided index with the
given value. If the index is negative, then it replaces from the end
of the array.
.[iterator](): IterableIterator<Item>
Iterator
[unscopables]: { length: boolean, toString: NO TYPE, toLocaleString: NO TYPE, pop: NO TYPE, push: NO TYPE, concat: NO TYPE, join: NO TYPE, reverse: NO TYPE, shift: NO TYPE, slice: NO TYPE, sort: NO TYPE, splice: NO TYPE, unshift: NO TYPE, indexOf: NO TYPE, lastIndexOf: NO TYPE, every: NO TYPE, some: NO TYPE, forEach: NO TYPE, map: NO TYPE, filter: NO TYPE, reduce: NO TYPE, reduceRight: NO TYPE, find: NO TYPE, findIndex: NO TYPE, fill: NO TYPE, copyWithin: NO TYPE, entries: NO TYPE, keys: NO TYPE, values: NO TYPE, includes: NO TYPE, flatMap: NO TYPE, flat: NO TYPE, at: NO TYPE, findLast: NO TYPE, findLastIndex: NO TYPE, toReversed: NO TYPE, toSorted: NO TYPE, toSpliced: NO TYPE, with: NO TYPE, [iterator]: NO TYPE, [unscopables]: boolean }
Is an object whose properties have the value 'true'
when they will be absent when used in a 'with' statement.

class CoStream<Item>

Content
.id: ID<CoStream<Item>>
⚠️ undocumented
Subscription & Loading
CoStream.load<S, Depth>(id, as, depth): Promise<DeeplyLoaded<S, Depth> | undefined>
S extends CoStream<any>
this: CoValueClass<S>,
id: ID<S>,
as: Account,
depth: Depth & DepthsIn<S>
⚠️ undocumented
CoStream.subscribe<S, Depth>(id, as, depth, listener): () => void
S extends CoStream<any>
this: CoValueClass<S>,
id: ID<S>,
as: Account,
depth: Depth & DepthsIn<S>,
listener: (value: DeeplyLoaded<S, Depth>) => void
⚠️ undocumented
.ensureLoaded<S, Depth>(depth): Promise<DeeplyLoaded<S, Depth> | undefined>
S extends CoStream<any>
this: S,
depth: Depth & DepthsIn<S>
⚠️ undocumented
.subscribe<S, Depth>(depth, listener): () => void
S extends CoStream<any>
this: S,
depth: Depth & DepthsIn<S>,
listener: (value: DeeplyLoaded<S, Depth>) => void
⚠️ undocumented
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): { in: { undefined }, id: ID<CoStream<Item>>, _type: "CoStream" }
⚠️ undocumented
.[inspect](): { in: { undefined }, id: ID<CoStream<Item>>, _type: "CoStream" }
⚠️ undocumented
Internals
CoStream.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoStream<JsonValue, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoStream"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
CoStream.Of<Item>(item): CoStream
item: IfCo<Item, Item>
⚠️ undocumented
CoStream._schema: any
⚠️ undocumented
CoStream.create<S>(init, options): S
S extends CoStream<any>
this: CoValueClass<S>,
init: TODO type conditional,
options: { owner: Group | Account }
⚠️ undocumented
CoStream.schema<V>(def): void
V extends CoStream<any>
this: TODO reflection type 512 & CoStream,
def: { [ItemsSym]: V["_schema"][ItemsSym] }
⚠️ undocumented
.constructor: NO TYPE
⚠️ undocumented
._schema: { [ItemsSym]: SchemaFor<Item> }
⚠️ undocumented
.byMe: CoStreamEntry<Item> | undefined
⚠️ undocumented
.perSession: { undefined }
⚠️ undocumented
.inCurrentSession: CoStreamEntry<Item> | undefined
⚠️ undocumented
.push(items): void
items: Item[]
⚠️ undocumented
.pushItem(item): void
item: Item
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

class BinaryCoStream

Content
.id: ID<BinaryCoStream>
⚠️ undocumented
Subscription & Loading
BinaryCoStream.load<B, Depth>(id, as, depth): Promise<DeeplyLoaded<B, Depth> | undefined>
B extends BinaryCoStream
this: CoValueClass<B>,
id: ID<B>,
as: Account,
depth: Depth & DepthsIn<B>
⚠️ undocumented
BinaryCoStream.subscribe<B, Depth>(id, as, depth, listener): () => void
B extends BinaryCoStream
this: CoValueClass<B>,
id: ID<B>,
as: Account,
depth: Depth & DepthsIn<B>,
listener: (value: DeeplyLoaded<B, Depth>) => void
⚠️ undocumented
.ensureLoaded<B, Depth>(depth): Promise<DeeplyLoaded<B, Depth> | undefined>
B extends BinaryCoStream
this: B,
depth: Depth & DepthsIn<B>
⚠️ undocumented
.subscribe<B, Depth>(depth, listener): () => void
B extends BinaryCoStream
this: B,
depth: Depth & DepthsIn<B>,
listener: (value: DeeplyLoaded<B, Depth>) => void
⚠️ undocumented
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): { id: ID<BinaryCoStream>, _type: "BinaryCoStream", mimeType: string, fileName: string, totalSizeBytes: number, chunks: Uint8Array[], finished: boolean }
⚠️ undocumented
.[inspect](): { id: ID<BinaryCoStream>, _type: "BinaryCoStream", mimeType: string, fileName: string, totalSizeBytes: number, chunks: Uint8Array[], finished: boolean }
⚠️ undocumented
Internals
BinaryCoStream.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawBinaryCoStream<{ type: "binary" }>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "BinaryCoStream"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
BinaryCoStream.create<S>(options): S
S extends BinaryCoStream
this: CoValueClass<S>,
options: { owner: Group | Account }
⚠️ undocumented
BinaryCoStream.loadAsBlob(id, as, options): Promise<Blob | undefined>
id: ID<BinaryCoStream>,
as: Account,
options: { allowUnfinished: boolean }
⚠️ undocumented
BinaryCoStream.createFromBlob(blob, options): Promise<BinaryCoStream>
blob: File | Blob,
options: { owner: Group | Account, onProgress: (progress: number) => void }
⚠️ undocumented
.constructor: NO TYPE
⚠️ undocumented
.getChunks(options): BinaryStreamInfo & { chunks: Uint8Array[], finished: boolean } | undefined
options: { allowUnfinished: boolean }
⚠️ undocumented
.isBinaryStreamEnded(): boolean
⚠️ undocumented
.start(options): void
options: BinaryStreamInfo
⚠️ undocumented
.push(data): void
data: Uint8Array
⚠️ undocumented
.end(): void
⚠️ undocumented
.toBlob(options): Blob | undefined
options: { allowUnfinished: boolean }
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

Identity & Permissions

class Group

Content
.id: ID<Group>
⚠️ undocumented
Subscription & Loading
Group.load<G, Depth>(id, as, depth): Promise<DeeplyLoaded<G, Depth> | undefined>
G extends Group
this: CoValueClass<G>,
id: ID<G>,
as: Account,
depth: Depth & DepthsIn<G>
⚠️ undocumented
Group.subscribe<G, Depth>(id, as, depth, listener): () => void
G extends Group
this: CoValueClass<G>,
id: ID<G>,
as: Account,
depth: Depth & DepthsIn<G>,
listener: (value: DeeplyLoaded<G, Depth>) => void
⚠️ undocumented
.ensureLoaded<G, Depth>(depth): Promise<DeeplyLoaded<G, Depth> | undefined>
G extends Group
this: G,
depth: Depth & DepthsIn<G>
⚠️ undocumented
.subscribe<G, Depth>(depth, listener): () => void
G extends Group
this: G,
depth: Depth & DepthsIn<G>,
listener: (value: DeeplyLoaded<G, Depth>) => void
⚠️ undocumented
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): any[] | string | object
⚠️ undocumented
.[inspect](): any[] | string | object
⚠️ undocumented
Internals
Group.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawGroup<JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "Group"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
Group._schema: any
⚠️ undocumented
Group.create<G>(options): G
G extends Group
this: CoValueClass<G>,
options: { owner: Account }
⚠️ undocumented
.constructor: NO TYPE
⚠️ undocumented
._schema: { profile: Schema, root: Schema, [MembersSym]: RefEncoded<Account> }
⚠️ undocumented
.profile: Profile | null
⚠️ undocumented
.root: CoMap | null
⚠️ undocumented
._refs: { profile: (TODO type conditional) | undefined, root: (TODO type conditional) | undefined }
⚠️ undocumented
.myRole(): Role | undefined
⚠️ undocumented
.addMember(member, role): Group
member: Account | "everyone",
role: Role
⚠️ undocumented
.members: { id: ID<this[MembersSym]> | "everyone", role: Role | undefined, ref: Ref<NonNullable<this[MembersSym]>> | undefined, account: NO TYPE }[]
⚠️ undocumented
[MembersSym]: Account | null
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

class Profile

Declaration
Profile.Record<Value>(value): RecordLikeCoMap
value: IfCo<Value, Value>
Declare a Record-like CoMap schema, by extending CoMap.Record(...) and passing the value schema using co. Keys are always string.
Example:
import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
 co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;
Content
.id: ID<Profile>
The ID of this CoMap
._refs: {[Key in string]: IfCo<this[Key], RefIfCoValue<this[Key]>>}
If property prop is a co.ref(...), you can use coMaps._refs.prop to access
the Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example:
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
Creation
Profile.create<M>(init, options): M
M extends CoMap
this: CoValueClass<M>,
init: Simplify<CoMapInit<M>>,
options: { owner: Group | Account, unique: JsonValue }
Create a new CoMap with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoMap will immediately be persisted and synced to connected peers.
Example:
const person = Person.create({
  name: "Alice",
  age: 42,
  pet: cat,
}, { owner: friendGroup });
Subscription & Loading
Profile.load<M, Depth>(id, as, depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: CoValueClass<M>,
id: ID<M>,
as: Account,
depth: Depth & DepthsIn<M>
Load a CoMap with a given ID, as a given account.

depth specifies which (if any) fields that reference other CoValues to load as well before resolving.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.
Example:
const person = await Person.load(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { pet: {} }
);
Profile.subscribe<M, Depth>(id, as, depth, listener): () => void
M extends CoMap
this: CoValueClass<M>,
id: ID<M>,
as: Account,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Load and subscribe to a CoMap with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies which (if any) fields that reference other CoValues to load as well before calling listener for the first time.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the useCoState hook to reactively subscribe to a CoValue in a React component.
Example:
const unsub = Person.subscribe(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { pet: {} },
  (person) => console.log(person)
);
.ensureLoaded<M, Depth>(depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>
Given an already loaded CoMap, ensure that the specified fields are loaded to the specified depth.

Works like CoMap.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<M, Depth>(depth, listener): () => void
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Given an already loaded CoMap, subscribe to updates to the CoMap and ensure that the specified fields are loaded to the specified depth.

Works like CoMap.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
Collaboration
._edits: {[Key in string]: IfCo<this[Key], CoMapEdit<this[Key]>>}
⚠️ undocumented
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
⚠️ undocumented
.[inspect](): any[]
⚠️ undocumented
Internals
Profile.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoMap<{ undefined }, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoMap"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
Profile.findUnique<M>(unique, ownerID, as): ID<M>
M extends CoMap
this: CoValueClass<M>,
unique: JsonValue,
ownerID: ID<Group> | ID<Account>,
as: AnonymousJazzAgent | Group | Account
⚠️ undocumented
.name: co<string>
⚠️ undocumented
.applyDiff<N>(newValues): Profile
N extends Partial<CoMapInit<Profile>>
newValues: N
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

class Account

Content
.id: ID<Account>
⚠️ undocumented
Subscription & Loading
Account.load<A, Depth>(id, as, depth): Promise<DeeplyLoaded<A, Depth> | undefined>
A extends Account
this: CoValueClass<A>,
id: ID<A>,
as: Account,
depth: Depth & DepthsIn<A>
⚠️ undocumented
Account.subscribe<A, Depth>(id, as, depth, listener): () => void
A extends Account
this: CoValueClass<A>,
id: ID<A>,
as: Account,
depth: Depth & DepthsIn<A>,
listener: (value: DeeplyLoaded<A, Depth>) => void
⚠️ undocumented
.ensureLoaded<A, Depth>(depth): Promise<DeeplyLoaded<A, Depth> | undefined>
A extends Account
this: A,
depth: Depth & DepthsIn<A>
⚠️ undocumented
.subscribe<A, Depth>(depth, listener): () => void
A extends Account
this: A,
depth: Depth & DepthsIn<A>,
listener: (value: DeeplyLoaded<A, Depth>) => void
⚠️ undocumented
Collaboration
._owner: Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): any[] | object
⚠️ undocumented
.[inspect](): any[] | object
⚠️ undocumented
Internals
Account.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawControlledAccount<AccountMeta> | RawAccount<AccountMeta>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "Account"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
Account._schema: any
⚠️ undocumented
Account.create<A>(options): Promise<A>
A extends Account
this: CoValueClass<A> & Account,
options: { creationProps: { name: string }, crypto: CryptoProvider<any>, initialAgentSecret: TODO type templateLiteral, peersToLoadFrom: Peer[] }
⚠️ undocumented
Account.createAs<A>(as, options): Promise<A>
A extends Account
this: CoValueClass<A> & Account,
as: Account,
options: { creationProps: { name: string } }
⚠️ undocumented
Account.fromNode<A>(node): A
A extends Account
this: CoValueClass<A>,
node: LocalNode
⚠️ undocumented
.constructor: NO TYPE
⚠️ undocumented
._schema: { profile: Schema, root: Schema }
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
.profile: Profile | null
⚠️ undocumented
.root: CoMap | null
⚠️ undocumented
._refs: { profile: RefIfCoValue<this["profile"]> | undefined, root: RefIfCoValue<this["root"]> | undefined }
⚠️ undocumented
.isMe: boolean
⚠️ undocumented
.sessionID: TODO type templateLiteral | TODO type templateLiteral | undefined
⚠️ undocumented
.myRole(): "admin" | undefined
⚠️ undocumented
.acceptInvite<V>(valueID, inviteSecret, coValueClass): Promise<(TODO type conditional) | undefined>
V extends CoValue
valueID: ID<V>,
inviteSecret: TODO type templateLiteral,
coValueClass: CoValueClass<V>
⚠️ undocumented
.migrate(creationProps): Promise<void> | void
this: Account,
creationProps: { name: string }
⚠️ undocumented
isControlledAccount(account): account is Account & { isMe: true, sessionID: TODO type templateLiteral | TODO type templateLiteral, _raw: RawControlledAccount<AccountMeta> }
account: Account

Schema definition

Encoders reflection

co reflection

type co

type co<T> = T & CoMarker | T

⚠️ undocumented

Abstract interfaces

interface CoValue

Content
.id: ID<CoValue>
⚠️ undocumented
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(key, seenAbove): any[] | string | object
key: string,
seenAbove: ID<CoValue>[]
⚠️ undocumented
.[inspect](): any
⚠️ undocumented
Internals
._raw: RawCoValue
⚠️ undocumented
Type Helpers
._type: string
⚠️ undocumented

interface CoValueClass<Value>

Value extends CoValue

Media

class ImageDefinition

Declaration
ImageDefinition.Record<Value>(value): RecordLikeCoMap
value: IfCo<Value, Value>
Declare a Record-like CoMap schema, by extending CoMap.Record(...) and passing the value schema using co. Keys are always string.
Example:
import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
 co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;
Content
.id: ID<ImageDefinition>
The ID of this CoMap
._refs: {[Key in string]: IfCo<this[Key], RefIfCoValue<this[Key]>>}
If property prop is a co.ref(...), you can use coMaps._refs.prop to access
the Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example:
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
Creation
ImageDefinition.create<M>(init, options): M
M extends CoMap
this: CoValueClass<M>,
init: Simplify<CoMapInit<M>>,
options: { owner: Group | Account, unique: JsonValue }
Create a new CoMap with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoMap will immediately be persisted and synced to connected peers.
Example:
const person = Person.create({
  name: "Alice",
  age: 42,
  pet: cat,
}, { owner: friendGroup });
Subscription & Loading
ImageDefinition.load<M, Depth>(id, as, depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: CoValueClass<M>,
id: ID<M>,
as: Account,
depth: Depth & DepthsIn<M>
Load a CoMap with a given ID, as a given account.

depth specifies which (if any) fields that reference other CoValues to load as well before resolving.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.
Example:
const person = await Person.load(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { pet: {} }
);
ImageDefinition.subscribe<M, Depth>(id, as, depth, listener): () => void
M extends CoMap
this: CoValueClass<M>,
id: ID<M>,
as: Account,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Load and subscribe to a CoMap with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies which (if any) fields that reference other CoValues to load as well before calling listener for the first time.
The DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass [] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the useCoState hook to reactively subscribe to a CoValue in a React component.
Example:
const unsub = Person.subscribe(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { pet: {} },
  (person) => console.log(person)
);
.ensureLoaded<M, Depth>(depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>
Given an already loaded CoMap, ensure that the specified fields are loaded to the specified depth.

Works like CoMap.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<M, Depth>(depth, listener): () => void
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Given an already loaded CoMap, subscribe to updates to the CoMap and ensure that the specified fields are loaded to the specified depth.

Works like CoMap.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
Collaboration
._edits: {[Key in string]: IfCo<this[Key], CoMapEdit<this[Key]>>}
⚠️ undocumented
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
⚠️ undocumented
.[inspect](): any[]
⚠️ undocumented
Internals
ImageDefinition.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoMap<{ undefined }, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoMap"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
ImageDefinition.findUnique<M>(unique, ownerID, as): ID<M>
M extends CoMap
this: CoValueClass<M>,
unique: JsonValue,
ownerID: ID<Group> | ID<Account>,
as: AnonymousJazzAgent | Group | Account
⚠️ undocumented
.originalSize: co<[number, number]>
⚠️ undocumented
.highestResAvailable(options): { res: TODO type templateLiteral, stream: BinaryCoStream } | undefined
options: { maxWidth: number }
⚠️ undocumented
[ItemsSym]: co<BinaryCoStream | null>
⚠️ undocumented
.applyDiff<N>(newValues): ImageDefinition
N extends Partial<CoMapInit<ImageDefinition>>
newValues: N
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
.placeholderDataURL: co<string>
⚠️ undocumented

Other

class WasmCrypto

class PureJSCrypto

type InviteSecret

type InviteSecretundefined = TODO type templateLiteral

⚠️ undocumented

interface Peer

type SessionID

type SessionIDundefined = TODO type templateLiteral

⚠️ undocumented

type AgentID

type AgentIDundefined = TODO type templateLiteral

⚠️ undocumented

type SyncMessage

type SyncMessageundefined = DoneMessage | NewContentMessage | KnownStateMessage | LoadMessage

⚠️ undocumented

class CryptoProvider<Blake3State>

type CoValueUniqueness

type CoValueUniquenessundefined = { uniqueness: JsonValue, createdAt: null | TODO type templateLiteral }

⚠️ undocumented

type CoMapInit

type CoMapInit<Map extends object> = {[Key in CoKeys<Map>]: ForceRequiredRef<Map[Key]>} & {[Key in CoKeys<Map>]: ForceRequiredRef<Map[Key]>}

⚠️ undocumented

type AccountClass

type AccountClass<Acc extends Account> = CoValueClass<Acc> & { fromNode: Account["fromNode"] }

⚠️ undocumented

type DepthsIn

type DepthsIn<V, DepthLimit extends number, CurrentDepth extends number[]> = never[] | (TODO type conditional)

⚠️ undocumented

type DeeplyLoaded

type DeeplyLoaded<V, Depth, DepthLimit extends number, CurrentDepth extends number[]> = TODO type conditional

⚠️ undocumented
loadCoValue<V, Depth>(cls, id, as, depth): Promise<DeeplyLoaded<V, Depth> | undefined>
cls: CoValueClass<V>,
id: ID<V>,
as: AnonymousJazzAgent | Account,
depth: Depth & DepthsIn<V>
subscribeToCoValue<V, Depth>(cls, id, as, depth, listener, onUnavailable): () => void
cls: CoValueClass<V>,
id: ID<V>,
as: AnonymousJazzAgent | Account,
depth: Depth & DepthsIn<V>,
listener: (value: DeeplyLoaded<V, Depth>) => void,
onUnavailable: () => void

interface AuthMethod

type AuthResult

type AuthResultundefined = { type: "new", creationProps: { name: string }, saveCredentials: (credentials: { accountID: ID<Account>, secret: AgentSecret }) => Promise<void>, onSuccess: () => void, onError: (error: Error | string) => void, logOut: () => void, initialSecret: AgentSecret } | { type: "existing", credentials: { accountID: ID<Account>, secret: AgentSecret }, onSuccess: () => void, onError: (error: Error | string) => void, logOut: () => void }

⚠️ undocumented
createJazzContext<Acc>(__namedParameters): Promise<JazzContextWithAccount<Acc>>
ContextParamsWithAuth<Acc>
createJazzContext(__namedParameters): Promise<JazzContextWithAgent>
BaseContextParams
createJazzContext<Acc>(options): Promise<JazzContext<Acc>>
options: ContextParamsWithAuth<Acc> | BaseContextParams
fixedCredentialsAuth(credentials): AuthMethod
credentials: { accountID: ID<Account>, secret: TODO type templateLiteral }
ephemeralCredentialsAuth(): AuthMethod

class AnonymousJazzAgent

createAnonymousJazzContext({ peersToLoadFrom, crypto }): Promise<JazzContextWithAgent>
{ peersToLoadFrom: Peer[], crypto: CryptoProvider<any> }
randomSessionProvider(accountID, crypto): Promise<{ sessionID: TODO type templateLiteral | TODO type templateLiteral, sessionDone: () => void }>
accountID: ID<Account>,
crypto: CryptoProvider<any>