Public sharing and invites

Public sharing

You can share CoValues publicly by setting the owner to a Group, and granting access to "everyone".

const const group: Groupgroup = class Group
@categoryIdentity & Permissions
Group.
Group.create<Group>(this: CoValueClass<Group>, options?: {
    owner: Account;
} | Account): Group
create();
const group: Groupgroup.Group.addMember(member: Everyone, role: "writer" | "reader" | "writeOnly"): void (+3 overloads)addMember("everyone", "writer");

You can also use makePublic(role) alias to grant access to everyone with a specific role (defaults to reader).

const const group: Groupgroup = class Group
@categoryIdentity & Permissions
Group.
Group.create<Group>(this: CoValueClass<Group>, options?: {
    owner: Account;
} | Account): Group
create();
const group: Groupgroup.Group.addMember(member: Everyone, role: "writer" | "reader" | "writeOnly"): void (+3 overloads)addMember("everyone", "writer"); 
const group: Groupgroup.Group.makePublic(role?: "reader" | "writer"): Group
Make the group public, so that everyone can read it.
Alias for `addMember("everyone", role)`.
@paramrole - Optional: the role to grant to everyone. Defaults to "reader".@returnsThe group itself.
makePublic("writer"); 
// group.makePublic(); // Defaults to "reader" access

This is done in the chat example where anyone can join the chat, and send messages.

You can also add members by Account ID.

Invites

You can grant users access to a CoValue by sending them an invite link.

This is used in the todo example.

import { 
function createInviteLink<C extends CoValue>(value: C, role: "reader" | "writer" | "admin" | "writeOnly", { baseURL, valueHint, }?: {
    baseURL?: string;
    valueHint?: string;
}): string
@categoryInvite Links
createInviteLink } from "jazz-tools/react";


createInviteLink<{
    readonly name: string;
} & CoMap>(value: {
    readonly name: string;
} & CoMap, role: "reader" | "writer" | "admin" | "writeOnly", { baseURL, valueHint, }?: {
    baseURL?: string;
    valueHint?: string;
}): string
@categoryInvite Links
createInviteLink(
const organization: {
    readonly name: string;
} & CoMap
organization, "writer"); // or reader, admin, writeOnly

It generates a URL that looks like .../invite/[CoValue ID]/[inviteSecret]

In your app, you need to handle this route, and let the user accept the invitation, as done here.

import { 
function useAcceptInvite<S extends CoValueClassOrSchema>({ invitedObjectSchema, onAccept, forValueHint, }: {
    invitedObjectSchema: S;
    onAccept: (valueID: string) => void;
    forValueHint?: string;
}): void
useAcceptInvite } from "jazz-tools/react";


useAcceptInvite<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>({ invitedObjectSchema, onAccept, forValueHint, }: {
    invitedObjectSchema: co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>;
    onAccept: (valueID: string) => void;
    forValueHint?: string;
}): void
useAcceptInvite({
  
invitedObjectSchema: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>
invitedObjectSchema: 
const Organization: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>
Organization,
  onAccept: (valueID: string) => voidonAccept: (organizationID: stringorganizationID) => {
    var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)
console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log("Accepted invite!")
    // navigate to the organization page
  },
});

You can accept an invitation programmatically by using the acceptInvite method on an account. Pass the ID of the CoValue you're being invited to, the secret from the invite link, and the schema of the CoValue.

await const account: Accountaccount.
Account.acceptInvite<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>(valueID: string, inviteSecret: InviteSecret, coValueClass: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>): Promise<...>
Accept an invite to a `CoValue` or `Group`.
@paramvalueID The ID of the `CoValue` or `Group` to accept the invite to.@paraminviteSecret The secret of the invite to accept.@paramcoValueClass The class of the `CoValue` or `Group` to accept the invite to.@returnsThe loaded `CoValue` or `Group`.
acceptInvite(
  const organizationId: ""organizationId,
  const inviteSecret: "inviteSecret_z"inviteSecret,
  
const Organization: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>
Organization
);

Requesting Invites

To allow a non-group member to request an invitation to a group you can use the writeOnly role. This means that users only have write access to a specific requests list (they can't read other requests). However, Administrators can review and approve these requests.

Create the data models.

const 
const JoinRequest: co.Map<{
    account: <Shape extends BaseAccountShape>(shape?: Shape) => co.Account<Shape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>
JoinRequest = import coco.
map<{
    account: <Shape extends BaseAccountShape>(shape?: Shape) => co.Account<Shape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}>(shape: {
    ...;
}): co.Map<...>
export map
map({
  account: <Shape extends BaseAccountShape>(shape?: Shape) => co.Account<Shape>account: import coco.
const account: <Shape extends BaseAccountShape>(shape?: Shape) => co.Account<Shape>
export account
Defines a collaborative account schema for Jazz applications.

Creates an account schema that represents a user account with profile and root data.
Accounts are the primary way to identify and manage users in Jazz applications.
@templateShape - The shape of the account schema extending BaseAccountShape@paramshape - The account schema shape. Defaults to a basic profile with name, inbox, and inboxInvite fields, plus an empty root object.@example```typescript
// Basic account with default profile
const BasicAccount = co.account();

// Custom account with specific profile and root structure
const JazzAccount = co.account({
  profile: co.profile({
    name: z.string(),
    avatar: z.optional(z.string()),
  }),
  root: co.map({
    organizations: co.list(Organization),
    draftOrganization: DraftOrganization,
  }),
}).withMigration(async (account) => {
  // Migration logic for existing accounts
  if (!account.$jazz.has("profile")) {
    const group = Group.create();
    account.$jazz.set("profile", co.profile().create(
      { name: getRandomUsername() },
      group
    ));
    group.addMember("everyone", "reader");
  }
});
```
account,
  status: z.z.ZodLiteral<"pending" | "approved" | "rejected">status: import zz.
literal<readonly ["pending", "approved", "rejected"]>(value: readonly ["pending", "approved", "rejected"], params?: string | z.z.core.$ZodLiteralParams): z.z.ZodLiteral<"pending" | "approved" | "rejected"> (+1 overload)
export literal
literal(["pending", "approved", "rejected"]),
});

const 
const RequestsList: co.List<co.Map<{
    account: <Shape extends BaseAccountShape>(shape?: Shape) => co.Account<Shape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>>
RequestsList = import coco.
list<co.Map<{
    account: <Shape extends BaseAccountShape>(shape?: Shape) => co.Account<Shape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>>(element: co.Map<...>): co.List<...>
export list
list(
const JoinRequest: co.Map<{
    account: <Shape extends BaseAccountShape>(shape?: Shape) => co.Account<Shape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>
JoinRequest);

Set up the request system with appropriate access controls.

function 
function createRequestsToJoin(): CoListInstance<co.Map<{
    account: co.Account<BaseAccountShape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>>
createRequestsToJoin() {
  const const requestsGroup: GrouprequestsGroup = class Group
@categoryIdentity & Permissions
Group.
Group.create<Group>(this: CoValueClass<Group>, options?: {
    owner: Account;
} | Account): Group
create();
  const requestsGroup: GrouprequestsGroup.Group.addMember(member: Everyone, role: "writer" | "reader" | "writeOnly"): void (+3 overloads)addMember("everyone", "writeOnly");

  return 
const RequestsList: co.List<co.Map<{
    account: co.Account<BaseAccountShape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>>
RequestsList.
CoListSchema<CoMapSchema<{ account: AccountSchema<BaseAccountShape>; status: ZodLiteral<"pending" | "approved" | "rejected">; }, unknown, Account | Group>>.create(items: readonly (({
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | {
    ...;
})[], options?: {
    owner: Group;
    unique?: CoValueUniqueness["uniqueness"];
} | Group): CoListInstance<...> (+1 overload)
create([], const requestsGroup: GrouprequestsGroup);
}

async function 
function sendJoinRequest(requestsList: co.loaded<typeof RequestsList>, account: Account): Promise<{
    readonly account: {
        readonly profile: {
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap;
        readonly root: {
            ...;
        } & CoMap;
    } & Account;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap>
sendJoinRequest(
  
requestsList: CoList<({
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>
requestsList: import coco.
type loaded<T extends CoValueClassOrSchema, R extends ResolveQuery<T> = true> = R extends boolean | undefined ? NonNullable<InstanceOfSchemaCoValuesNullable<T>> : [NonNullable<InstanceOfSchemaCoValuesNullable<T>>] extends [...] ? Exclude<...> extends CoValue ? R extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean ...
export loaded
loaded<typeof 
const RequestsList: co.List<co.Map<{
    account: co.Account<BaseAccountShape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>>
RequestsList>,
  
account: {
    readonly profile: ({
        readonly name: string;
        readonly inbox?: string | undefined;
        readonly inboxInvite?: string | undefined;
    } & CoMap) | null;
    readonly root: ({
        ...;
    } & CoMap) | null;
} & Account
account: 
type Account = {
    readonly profile: ({
        readonly name: string;
        readonly inbox?: string | undefined;
        readonly inboxInvite?: string | undefined;
    } & CoMap) | null;
    readonly root: ({
        ...;
    } & CoMap) | null;
} & Account
Account,
) {
  const 
const request: {
    readonly account: {
        readonly profile: {
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap;
        readonly root: {
            readonly [x: string]: any;
        } & CoMap;
    } & Account;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap
request = 
const JoinRequest: co.Map<{
    account: co.Account<BaseAccountShape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>
JoinRequest.
CoMapSchema<{ account: AccountSchema<BaseAccountShape>; status: ZodLiteral<"pending" | "approved" | "rejected">; }, unknown, Account | Group>.create(init: {
    account: {
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            readonly [x: string]: any;
        } & CoMap) | null;
    } & Account;
    status: "pending" | ... 1 more ... | "rejected";
}, options?: {
    owner?: Group;
    unique?: CoValueUniqueness["uniqueness"];
} | Group): {
    ...;
} & CoMap (+1 overload)
create(
    {
      
account: {
    readonly profile: ({
        readonly name: string;
        readonly inbox?: string | undefined;
        readonly inboxInvite?: string | undefined;
    } & CoMap) | null;
    readonly root: ({
        ...;
    } & CoMap) | null;
} & Account
account,
      status: "pending" | "approved" | "rejected"status: "pending",
    },
    
requestsList: CoList<({
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>
requestsList.
CoList<({ readonly account: ({ readonly profile: ({ readonly name: string; readonly inbox?: string | undefined; readonly inboxInvite?: string | undefined; } & CoMap) | null; readonly root: ({ ...; } & CoMap) | null; } & Account) | null; readonly status: "pending" | ... 1 more ... | "rejected"; } & CoMap) | null>.$jazz: CoListJazzApi<CoList<({
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>>
$jazz.CoListJazzApi<CoList<({ readonly account: ({ readonly profile: ({ readonly name: string; readonly inbox?: string | undefined; readonly inboxInvite?: string | undefined; } & CoMap) | null; readonly root: ({ ...; } & CoMap) | null; } & Account) | null; readonly status: "pending" | ... 1 more ... | "rejected"; } & CoMap) | null>>.owner: Group
@categoryCollaboration
owner // Inherit the access controls of the requestsList
  );

  
requestsList: CoList<({
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>
requestsList.
CoList<({ readonly account: ({ readonly profile: ({ readonly name: string; readonly inbox?: string | undefined; readonly inboxInvite?: string | undefined; } & CoMap) | null; readonly root: ({ ...; } & CoMap) | null; } & Account) | null; readonly status: "pending" | ... 1 more ... | "rejected"; } & CoMap) | null>.$jazz: CoListJazzApi<CoList<({
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>>
$jazz.
CoListJazzApi<CoList<({ readonly account: ({ readonly profile: ({ readonly name: string; readonly inbox?: string | undefined; readonly inboxInvite?: string | undefined; } & CoMap) | null; readonly root: ({ ...; } & CoMap) | null; } & Account) | null; readonly status: "pending" | ... 1 more ... | "rejected"; } & CoMap) | null>>.push(...items: (({
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | CoMapInit<...> | null)[]): number
Appends new elements to the end of an array, and returns the new length of the array.
@paramitems New elements to add to the array.@categoryContent
push(
const request: {
    readonly account: {
        readonly profile: {
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap;
        readonly root: {
            readonly [x: string]: any;
        } & CoMap;
    } & Account;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap
request);

  return 
const request: {
    readonly account: {
        readonly profile: {
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap;
        readonly root: {
            readonly [x: string]: any;
        } & CoMap;
    } & Account;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap
request;
}

Using the write-only access users can submit requests that only administrators can review and approve.

async function 
function approveJoinRequest(joinRequest: co.loaded<typeof JoinRequest, {
    account: true;
}>, targetGroup: Group): Promise<boolean>
approveJoinRequest(
  
joinRequest: CoMapLikeLoaded<{
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap, {
    ...;
}, 10, []>
joinRequest: import coco.
type loaded<T extends CoValueClassOrSchema, R extends ResolveQuery<T> = true> = R extends boolean | undefined ? NonNullable<InstanceOfSchemaCoValuesNullable<T>> : [NonNullable<InstanceOfSchemaCoValuesNullable<T>>] extends [...] ? Exclude<...> extends CoValue ? R extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? readonly ((CoValue & ... 1 more ... & (ItemDepth extends boolean ...
export loaded
loaded<typeof 
const JoinRequest: co.Map<{
    account: co.Account<BaseAccountShape>;
    status: z.z.ZodLiteral<"pending" | "approved" | "rejected">;
}, unknown, Account | Group>
JoinRequest, { account: trueaccount: true }>,
  targetGroup: GrouptargetGroup: class Group
@categoryIdentity & Permissions
Group,
) {
  const 
const account: ({
    readonly profile: ({
        readonly name: string;
        readonly inbox?: string | undefined;
        readonly inboxInvite?: string | undefined;
    } & CoMap) | null;
    readonly root: ({
        ...;
    } & CoMap) | null;
} & Account) | CoMapLikeLoaded<...> | null
account = await const Account: co.Account<BaseAccountShape>Account.
AccountSchema<BaseAccountShape>.load: <ResolveQuery<co.Account<BaseAccountShape>>>(id: string, options?: {
    loadAs?: Account | AnonymousJazzAgent;
    resolve?: ({
        ...;
    } & {
        ...;
    }) | ... 1 more ... | undefined;
} | undefined) => Promise<...>
load(
joinRequest: CoMapLikeLoaded<{
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap, {
    ...;
}, 10, []>
joinRequest.
CoMap.$jazz: CoMapJazzApi<CoMapLikeLoaded<{
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap, {
    ...;
}, 10, []>>
Jazz methods for CoMaps are inside this property.

This allows CoMaps to be used as plain objects while still having
access to Jazz methods, and also doesn't limit which key names can be
used inside CoMaps.
$jazz.
CoMapJazzApi<CoMapLikeLoaded<{ readonly account: ({ readonly profile: ({ readonly name: string; readonly inbox?: string | undefined; readonly inboxInvite?: string | undefined; } & CoMap) | null; readonly root: ({ ...; } & CoMap) | null; } & Account) | null; readonly status: "pending" | ... 1 more ... | "rejected"; } & CoMap, { ...; }, 10, []>>.refs: {
    account: Ref<NonNullable<{
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account>>;
}
If property `prop` is a `coField.ref(...)`, you can use `coMap.$jazz.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```ts
person.$jazz.refs.pet.id; // => ID<Animal>
person.$jazz.refs.pet.value;
// => Animal | null
const pet = await person.$jazz.refs.pet.load();
```@categoryContent
refs.
account: Ref<NonNullable<{
    readonly profile: ({
        readonly name: string;
        readonly inbox?: string | undefined;
        readonly inboxInvite?: string | undefined;
    } & CoMap) | null;
    readonly root: ({
        ...;
    } & CoMap) | null;
} & Account>>
account.Ref<NonNullable<{ readonly profile: ({ readonly name: string; readonly inbox?: string | undefined; readonly inboxInvite?: string | undefined; } & CoMap) | null; readonly root: ({ ...; } & CoMap) | null; } & Account>>.id: stringid);

  if (
const account: ({
    readonly profile: ({
        readonly name: string;
        readonly inbox?: string | undefined;
        readonly inboxInvite?: string | undefined;
    } & CoMap) | null;
    readonly root: ({
        ...;
    } & CoMap) | null;
} & Account) | CoMapLikeLoaded<...> | null
account) {
    targetGroup: GrouptargetGroup.Group.addMember(member: Account, role: AccountRole): void (+3 overloads)addMember(
const account: ({
    readonly profile: ({
        readonly name: string;
        readonly inbox?: string | undefined;
        readonly inboxInvite?: string | undefined;
    } & CoMap) | null;
    readonly root: ({
        ...;
    } & CoMap) | null;
} & Account) | CoMapLikeLoaded<...>
account, "reader");
    
joinRequest: CoMapLikeLoaded<{
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap, {
    ...;
}, 10, []>
joinRequest.
CoMap.$jazz: CoMapJazzApi<CoMapLikeLoaded<{
    readonly account: ({
        readonly profile: ({
            readonly name: string;
            readonly inbox?: string | undefined;
            readonly inboxInvite?: string | undefined;
        } & CoMap) | null;
        readonly root: ({
            ...;
        } & CoMap) | null;
    } & Account) | null;
    readonly status: "pending" | ... 1 more ... | "rejected";
} & CoMap, {
    ...;
}, 10, []>>
Jazz methods for CoMaps are inside this property.

This allows CoMaps to be used as plain objects while still having
access to Jazz methods, and also doesn't limit which key names can be
used inside CoMaps.
$jazz.CoMapJazzApi<CoMapLikeLoaded<{ readonly account: ({ readonly profile: ({ readonly name: string; readonly inbox?: string | undefined; readonly inboxInvite?: string | undefined; } & CoMap) | null; readonly root: ({ ...; } & CoMap) | null; } & Account) | null; readonly status: "pending" | ... 1 more ... | "rejected"; } & CoMap, { ...; }, 10, []>>.set<"status">(key: "status", value: "pending" | "approved" | "rejected"): void
Set a value on the CoMap
@paramkey The key to set@paramvalue The value to set@categoryContent
set("status", "approved");

    return true;
  } else {
    return false;
  }
}
GitHubDocs issue?⌝DiscordJoin Discord⌝
Groups as permission scopes
Groups as members