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 (+2 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 (+2 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<{
    name: string;
} & CoMap>(value: {
    name: string;
} & CoMap, role: "reader" | "writer" | "admin" | "writeOnly", { baseURL, valueHint, }?: {
    baseURL?: string;
    valueHint?: string;
}): string
@categoryInvite Links
createInviteLink(
const organization: {
    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 useAcceptInviteNative<S extends CoValueOrZodSchema>({ invitedObjectSchema, onAccept, forValueHint, }: {
    invitedObjectSchema: S;
    onAccept: (projectID: string) => void;
    forValueHint?: string;
}): void
useAcceptInviteNative } from "jazz-tools/expo";


useAcceptInviteNative<CoMapSchema<{
    name: z.z.ZodString;
}>>({ invitedObjectSchema, onAccept, forValueHint, }: {
    invitedObjectSchema: CoMapSchema<{
        name: z.z.ZodString;
    }>;
    onAccept: (projectID: string) => void;
    forValueHint?: string;
}): void
useAcceptInviteNative({
  
invitedObjectSchema: CoMapSchema<{
    name: z.z.ZodString;
}>
invitedObjectSchema: 
const Organization: CoMapSchema<{
    name: z.z.ZodString;
}>
Organization,
  onAccept: (projectID: 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<CoMapSchema<{
    name: z.z.ZodString;
}>>(valueID: string, inviteSecret: InviteSecret, coValueClass: CoMapSchema<{
    name: z.z.ZodString;
}>): Promise<...>
acceptInvite(
  const organizationId: ""organizationId,
  const inviteSecret: "inviteSecret_z"inviteSecret,
  
const Organization: CoMapSchema<{
    name: z.z.ZodString;
}>
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: CoMapSchema<{
    account: <Shape extends {
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>(shape?: Shape) => AccountSchema<Shape>;
    status: z.z.ZodLiteral<...>;
}>
JoinRequest = import coco.
map<{
    account: <Shape extends {
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>(shape?: Shape) => AccountSchema<Shape>;
    status: z.z.ZodLiteral<...>;
}>(shape: {
    account: <Shape extends {
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>(shape?: Shape) => AccountSchema<Shape>;
    status: z.z.ZodLiteral<...>;
}): CoMapSchema<...>
export map
map({
  
account: <Shape extends {
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>(shape?: Shape) => AccountSchema<Shape>
account: import coco.
const account: <Shape extends {
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>(shape?: Shape) => AccountSchema<Shape>
export account
account,
  status: z.z.ZodLiteral<"pending" | "approved" | "rejected">status: import zz.
literal<["pending", "approved", "rejected"]>(value: ["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: CoListSchema<CoMapSchema<{
    account: <Shape extends {
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>(shape?: Shape) => AccountSchema<Shape>;
    status: z.z.ZodLiteral<...>;
}>>
RequestsList = import coco.
list<CoMapSchema<{
    account: <Shape extends {
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>(shape?: Shape) => AccountSchema<Shape>;
    status: z.z.ZodLiteral<...>;
}>>(element: CoMapSchema<...>): CoListSchema<...>
export list
list(
const JoinRequest: CoMapSchema<{
    account: <Shape extends {
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>(shape?: Shape) => AccountSchema<Shape>;
    status: z.z.ZodLiteral<...>;
}>
JoinRequest);

Set up the request system with appropriate access controls.

function 
function createRequestsToJoin(): CoList<{
    account: {
        profile: {
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap;
        root: {
            [x: string]: any;
        } & CoMap;
    } & {
        profile: Profile;
    } & Account;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap>
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 (+2 overloads)addMember("everyone", "writeOnly");

  return 
const RequestsList: CoListSchema<CoMapSchema<{
    account: AccountSchema<{
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>;
    status: z.z.ZodLiteral<...>;
}>>
RequestsList.
create: (items: CoListInit<CoMapSchema<{
    account: AccountSchema<{
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>;
    status: z.z.ZodLiteral<...>;
}>>, options?: {
    owner: Account | Group;
} | Account | Group) => CoList<...>
create([], const requestsGroup: GrouprequestsGroup);
}

async function 
function sendJoinRequest(requestsList: co.loaded<typeof RequestsList>, account: Account): Promise<{
    account: {
        profile: {
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap;
        root: {
            ...;
        } & CoMap;
    } & {
        ...;
    } & Account;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap>
sendJoinRequest(
  
requestsList: CoList<({
    account: ({
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account) | null;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>
requestsList: import coco.
type loaded<T extends CoValueClass | AnyCoSchema, R extends ResolveQuery<T> = true> = R extends boolean | undefined ? NonNullable<InstanceOfSchemaCoValuesNullable<T>> : [NonNullable<InstanceOfSchemaCoValuesNullable<T>>] extends [...] ? Exclude<...> extends CoValue ? R extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...
export loaded
loaded<typeof 
const RequestsList: CoListSchema<CoMapSchema<{
    account: AccountSchema<{
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>;
    status: z.z.ZodLiteral<...>;
}>>
RequestsList>,
  
account: {
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account
account: 
type Account = {
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account
Account,
) {
  const 
const request: {
    account: {
        profile: {
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap;
        root: {
            [x: string]: any;
        } & CoMap;
    } & {
        profile: Profile;
    } & Account;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap
request = 
const JoinRequest: CoMapSchema<{
    account: AccountSchema<{
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>;
    status: z.z.ZodLiteral<...>;
}>
JoinRequest.
create: (init: {
    account: {
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account;
    status: NonNullable<...>;
}, options?: Account | ... 2 more ... | undefined) => {
    ...;
} & CoMap
create(
    {
      
account: {
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & {
    profile: Profile | null;
} & Account
account,
      status: NonNullable<"pending" | "approved" | "rejected">status: "pending",
    },
    
requestsList: CoList<({
    account: ({
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account) | null;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>
requestsList.CoList<({ account: ({ profile: ({ name: string; inbox?: string | undefined; inboxInvite?: string | undefined; } & CoMap) | null; root: ({ [x: string]: any; } & CoMap) | null; } & { ...; } & Account) | null; status: "pending" | ... 1 more ... | "rejected"; } & CoMap) | null>._owner: Account | Group
@categoryCollaboration
_owner // Inherit the access controls of the requestsList
  );

  
requestsList: CoList<({
    account: ({
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account) | null;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | null>
requestsList.
CoList<({ account: ({ profile: ({ name: string; inbox?: string | undefined; inboxInvite?: string | undefined; } & CoMap) | null; root: ({ [x: string]: any; } & CoMap) | null; } & { ...; } & Account) | null; status: "pending" | ... 1 more ... | "rejected"; } & CoMap) | null>.push(...items: (({
    account: ({
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account) | null;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap) | 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.
push(
const request: {
    account: {
        profile: {
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap;
        root: {
            [x: string]: any;
        } & CoMap;
    } & {
        profile: Profile;
    } & Account;
    status: "pending" | ... 1 more ... | "rejected";
} & CoMap
request);

  return 
const request: {
    account: {
        profile: {
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap;
        root: {
            [x: string]: any;
        } & CoMap;
    } & {
        profile: Profile;
    } & Account;
    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: {
    account: {
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account;
} & {
    ...;
} & CoMap
joinRequest: import coco.
type loaded<T extends CoValueClass | AnyCoSchema, R extends ResolveQuery<T> = true> = R extends boolean | undefined ? NonNullable<InstanceOfSchemaCoValuesNullable<T>> : [NonNullable<InstanceOfSchemaCoValuesNullable<T>>] extends [...] ? Exclude<...> extends CoValue ? R extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...> extends CoValue ? ItemDepth extends {
    ...;
} ? ((CoValue & ... 1 more ... & (ItemDepth extends boolean | undefined ? CoValue & Exclude<...> : [...] extends [...] ? Exclude<...
export loaded
loaded<typeof 
const JoinRequest: CoMapSchema<{
    account: AccountSchema<{
        profile: AnyCoMapSchema<{
            name: z.z.core.$ZodString<string>;
            inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
            inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        }>;
        root: AnyCoMapSchema;
    }>;
    status: z.z.ZodLiteral<...>;
}>
JoinRequest, { account: trueaccount: true }>,
  targetGroup: GrouptargetGroup: class Group
@categoryIdentity & Permissions
Group,
) {
  const 
const account: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | null
account = await 
const Account: AccountSchema<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>
Account.
load: <ResolveQuery<AccountSchema<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>>>(id: string, options?: {
    ...;
} | undefined) => Promise<...>
load(
joinRequest: {
    account: {
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account;
} & {
    ...;
} & CoMap
joinRequest.
CoMap._refs: {
    account: Ref<NonNullable<{
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account>>;
}
If property `prop` is a `coField.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```ts
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
```@categoryContent
_refs.
account: Ref<NonNullable<{
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & {
    profile: Profile | null;
} & Account>>
account.Ref<NonNullable<{ profile: ({ name: string; inbox?: string | undefined; inboxInvite?: string | undefined; } & CoMap) | null; root: ({ [x: string]: any; } & CoMap) | null; } & { profile: Profile | null; } & Account>>.id: stringid);

  if (
const account: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | null
account) {
    targetGroup: GrouptargetGroup.Group.addMember(member: Account, role: AccountRole): void (+2 overloads)addMember(
const account: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account)
account, "reader");
    
joinRequest: {
    account: {
        profile: ({
            name: string;
            inbox?: string | undefined;
            inboxInvite?: string | undefined;
        } & CoMap) | null;
        root: ({
            [x: string]: any;
        } & CoMap) | null;
    } & {
        ...;
    } & Account;
} & {
    ...;
} & CoMap
joinRequest.status: "pending" | "approved" | "rejected"status = "approved";

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