How to share data between users through Organizations

This guide shows you how to share a set of CoValues between users. Different apps have different names for this concept, such as "teams" or "workspaces".

We'll use the term Organization.

See the full example here.

Defining the schema for an Organization

Create a CoMap shared by the users of the same organization to act as a root (or "main database") for the shared data within an organization.

For this example, users within an Organization will be sharing Projects.

// schema.ts
export const 
const Project: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>
Project = import coco.
map<{
    name: z.z.ZodString;
}>(shape: {
    name: z.z.ZodString;
}): co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>
export map
map({
  name: z.z.ZodStringname: import zz.
function string(params?: string | z.z.core.$ZodStringParams): z.z.ZodString (+1 overload)
export string
string(),
});

export const 
const Organization: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
Organization = import coco.
map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}>(shape: {
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}): co.Map<...>
export map
map({
  name: z.z.ZodStringname: import zz.
function string(params?: string | z.z.core.$ZodStringParams): z.z.ZodString (+1 overload)
export string
string(),

  // shared data between users of each organization
  
projects: co.List<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>
projects: import coco.
list<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>(element: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>): co.List<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>
export list
list(
const Project: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>
Project), 
});

export const 
const ListOfOrganizations: co.List<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>
ListOfOrganizations = import coco.
list<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>(element: co.Map<...>): co.List<...>
export list
list(
const Organization: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
Organization);

Learn more about defining schemas.

Adding a list of Organizations to the user's Account

Let's add the list of Organizations to the user's Account root so they can access them.

// schema.ts
export const 
const JazzAccountRoot: co.Map<{
    organizations: co.List<co.Map<{
        name: z.z.ZodString;
        projects: co.List<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
JazzAccountRoot = import coco.
map<{
    organizations: co.List<co.Map<{
        name: z.z.ZodString;
        projects: co.List<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>>;
}>(shape: {
    ...;
}): co.Map<...>
export map
map({
  
organizations: co.List<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>
organizations: import coco.
list<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>(element: co.Map<...>): co.List<...>
export list
list(
const Organization: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
Organization),
});

export const 
const JazzAccount: co.Account<{
    root: co.Map<{
        organizations: co.List<co.Map<{
            name: z.z.ZodString;
            projects: co.List<co.Map<{
                name: z.z.ZodString;
            }, unknown, Account | Group>>;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>;
    profile: co.Profile<...>;
}>
JazzAccount = import coco
  .
account<{
    root: co.Map<{
        organizations: co.List<co.Map<{
            name: z.z.ZodString;
            projects: co.List<co.Map<{
                name: z.z.ZodString;
            }, unknown, Account | Group>>;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>;
    profile: co.Profile<...>;
}>(shape?: {
    ...;
} | undefined): co.Account<...>
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({
    
root: co.Map<{
    organizations: co.List<co.Map<{
        name: z.z.ZodString;
        projects: co.List<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
root: 
const JazzAccountRoot: co.Map<{
    organizations: co.List<co.Map<{
        name: z.z.ZodString;
        projects: co.List<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
JazzAccountRoot,
    profile: co.Profile<BaseProfileShape>profile: import coco.
profile<BaseProfileShape>(shape?: (BaseProfileShape & Partial<DefaultProfileShape>) | undefined): co.Profile<BaseProfileShape>
export profile
profile(),
  })
  .
AccountSchema<{ root: CoMapSchema<{ organizations: CoListSchema<CoMapSchema<{ name: ZodString; projects: CoListSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; }, unknown, Account | Group>>; }, unknown, Account | Group>; profile: CoProfileSchema<...>; }>.withMigration(migration: (account: {
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account, creationProps?: {
    name: string;
}) => void): co.Account<...>
withMigration((
account: {
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account
account) => {
    if (!
account: {
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account
account.
Account.$jazz: AccountJazzApi<{
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account>
Jazz methods for Accounts are inside this property.

This allows Accounts to be used as plain objects while still having
access to Jazz methods.
$jazz.AccountJazzApi<{ readonly root: ({ readonly organizations: CoList<({ readonly name: string; readonly projects: CoList<({ readonly name: string; } & CoMap) | null> | null; } & CoMap) | null> | null; } & CoMap) | null; readonly profile: ({ ...; } & CoMap) | null; } & Account>.has(key: "root" | "profile"): booleanhas("root")) {
      // Using a Group as an owner allows you to give access to other users
      const const organizationGroup: GrouporganizationGroup = class Group
@categoryIdentity & Permissions
Group.
Group.create<Group>(this: CoValueClass<Group>, options?: {
    owner: Account;
} | Account): Group
create();

      const 
const organizations: CoListInstance<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>
organizations = import coco.
list<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>(element: co.Map<...>): co.List<...>
export list
list(
const Organization: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
Organization).
CoListSchema<CoMapSchema<{ name: ZodString; projects: CoListSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; }, unknown, Account | Group>>.create(items: readonly (({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | {
    name: string;
    projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | readonly (({
        readonly name: string;
    } & CoMap) | {
        ...;
    })[];
})[], options?: {
    owner: Group;
    unique?: CoValueUniqueness["uniqueness"];
} | Group): CoListInstance<...> (+1 overload)
create([
        // Create the first Organization so users can start right away
        
const Organization: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
Organization.
CoMapSchema<{ name: ZodString; projects: CoListSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; }, unknown, Account | Group>.create(init: {
    name: string;
    projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | readonly (({
        readonly name: string;
    } & CoMap) | {
        name: string;
    })[];
}, options?: {
    owner?: Group;
    unique?: CoValueUniqueness["uniqueness"];
} | Group): {
    ...;
} & CoMap (+1 overload)
create(
          {
            name: stringname: "My organization",
            
projects: CoList<({
    readonly name: string;
} & CoMap) | null> | readonly (({
    readonly name: string;
} & CoMap) | {
    name: string;
})[]
projects: import coco.
list<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>(element: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>): co.List<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>
export list
list(
const Project: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>
Project).
CoListSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>.create(items: readonly (({
    readonly name: string;
} & CoMap) | {
    name: string;
})[], options?: {
    owner: Group;
    unique?: CoValueUniqueness["uniqueness"];
} | Group): CoListInstance<...> (+1 overload)
create([], const organizationGroup: GrouporganizationGroup),
          },
          const organizationGroup: GrouporganizationGroup,
        ),
      ]);
      
account: {
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account
account.
Account.$jazz: AccountJazzApi<{
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account>
Jazz methods for Accounts are inside this property.

This allows Accounts to be used as plain objects while still having
access to Jazz methods.
$jazz.
AccountJazzApi<{ readonly root: ({ readonly organizations: CoList<({ readonly name: string; readonly projects: CoList<({ readonly name: string; } & CoMap) | null> | null; } & CoMap) | null> | null; } & CoMap) | null; readonly profile: ({ ...; } & CoMap) | null; } & Account>.set<"root">(key: "root", value: ({
    readonly organizations: CoList<({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap) | null> | null;
} & CoMap) | CoMapInit<...>): void
Set the value of a key in the account.
@paramkey The key to set.@paramvalue The value to set.@categoryContent
set("root", { 
organizations: CoListInstance<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>
organizations });
    }
  });

This schema now allows users to create Organizations and add Projects to them.

See the schema for the example app here.

Adding members to an Organization

Here are different ways to add members to an Organization.

This guide and the example app show you the first method.

Here's how you can generate an invite link.

When the user accepts the invite, add the Organization to the user's organizations list.

export function function AcceptInvitePage(): React.JSX.ElementAcceptInvitePage() {
  const { 
const me: CoMapLikeLoaded<{
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account, {
    ...;
}, 10, []> | null | undefined
me } = 
useAccount<co.Account<{
    root: co.Map<{
        organizations: co.List<co.Map<{
            name: z.z.ZodString;
            projects: co.List<co.Map<{
                name: z.z.ZodString;
            }, unknown, Account | Group>>;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>;
    profile: co.Profile<...>;
}>, {
    ...;
}>(AccountSchema?: co.Account<...> | undefined, options?: {
    ...;
} | undefined): {
    ...;
}
React hook for accessing the current user's account and authentication state.

This hook provides access to the current user's account profile and root data,
along with authentication utilities. It automatically handles subscription to
the user's account data and provides a logout function.
@returnsAn object containing:
- `me`: The loaded account data, or `undefined` if loading, or `null` if not authenticated
- `agent`: The current agent (anonymous or authenticated user). Can be used as `loadAs` parameter for load and subscribe methods.
- `logOut`: Function to log out the current user@example```tsx
// Deep loading with resolve queries
function ProjectListWithDetails() {
  const { me } = useAccount(MyAppAccount, {
    resolve: {
      profile: true,
      root: {
        myProjects: {
          $each: {
            tasks: true,
          },
        },
      },
    },
  });

  if (!me) {
    return me === null
      ? <div>Failed to load your projects</div>
      : <div>Loading...</div>;
  }

  return (
    <div>
      <h1>{me.profile.name}'s projects</h1>
      <ul>
        {me.root.myProjects.map((project) => (
          <li key={project.id}>
            {project.name} ({project.tasks.length} tasks)
          </li>
        ))}
      </ul>
    </div>
  );
}
```
useAccount(
const JazzAccount: co.Account<{
    root: co.Map<{
        organizations: co.List<co.Map<{
            name: z.z.ZodString;
            projects: co.List<co.Map<{
                name: z.z.ZodString;
            }, unknown, Account | Group>>;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>;
    profile: co.Profile<...>;
}>
JazzAccount, {
    
resolve?: RefsToResolve<{
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account, 10, []> | undefined
Resolve query to specify which nested CoValues to load from the account
resolve: { 
root?: RefsToResolve<{
    readonly organizations: CoList<({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap) | null> | null;
} & CoMap, 10, [...]> | undefined
root: { 
organizations?: RefsToResolve<CoList<({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | null>, 10, [0, 0]> | undefined
organizations: { 
$each?: RefsToResolve<{
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap, 10, [0, 0, 0]> | undefined
$each: { $onError?: null | undefined$onError: null } } } },
  });

  const const onAccept: (organizationId: string) => voidonAccept = (organizationId: stringorganizationId: string) => {
    if (
const me: CoMapLikeLoaded<{
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account, {
    ...;
}, 10, []> | null | undefined
me) {
      
const Organization: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
Organization.
CoMapSchema<{ name: ZodString; projects: CoListSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; }, unknown, Account | Group>.load<true>(id: string, options?: {
    resolve?: RefsToResolve<{
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap, 10, []> | undefined;
    loadAs?: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
    unstable_branch?: BranchDefinition;
} | undefined): Promise<...>
load(organizationId: stringorganizationId).
Promise<({ readonly name: string; readonly projects: CoList<({ readonly name: string; } & CoMap) | null> | null; } & CoMap) | null>.then<void, never>(onfulfilled?: ((value: ({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | null) => void | PromiseLike<...>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<...>) | ... 1 more ... | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then((
organization: ({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | null
organization) => {
        if (
organization: ({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | null
organization) {
          // avoid duplicates
          const const ids: (string | undefined)[]ids = 
const me: CoMapLikeLoaded<{
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account, {
    ...;
}, 10, []>
me.
Account.root: {
    readonly organizations: readonly (({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap & {}) | null)[] & CoList<({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap) | null>;
} & {
    readonly organizations: CoList<({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap) | null> | null;
} & CoMap
root.
organizations: readonly (({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}) | null)[] & CoList<({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | null>
organizations.
map<string | undefined>(callbackfn: (value: ({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}) | null, index: number, array: readonly (({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & ... 1 more ... & {}) | null)[]) => string | undefined, thisArg?: any): (string | undefined)[] (+1 overload)
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@paramcallbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.@paramthisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
map(
            (
organization: ({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}) | null
organization) => 
organization: ({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}) | null
organization?.
CoMap.$jazz: CoMapJazzApi<{
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}>
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.CoValueJazzApi<V extends CoValue>.id: string | undefinedid,
          );
          if (const ids: (string | undefined)[]ids.Array<string | undefined>.includes(searchElement: string | undefined, fromIndex?: number): boolean
Determines whether an array includes a certain element, returning true or false as appropriate.
@paramsearchElement The element to search for.@paramfromIndex The position in this array at which to begin searching for searchElement.
includes(organizationId: stringorganizationId)) return;

          
const me: CoMapLikeLoaded<{
    readonly root: ({
        readonly organizations: CoList<({
            readonly name: string;
            readonly projects: CoList<({
                readonly name: string;
            } & CoMap) | null> | null;
        } & CoMap) | null> | null;
    } & CoMap) | null;
    readonly profile: ({
        ...;
    } & CoMap) | null;
} & Account, {
    ...;
}, 10, []>
me.
Account.root: {
    readonly organizations: readonly (({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap & {}) | null)[] & CoList<({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap) | null>;
} & {
    readonly organizations: CoList<({
        readonly name: string;
        readonly projects: CoList<({
            readonly name: string;
        } & CoMap) | null> | null;
    } & CoMap) | null> | null;
} & CoMap
root.
organizations: readonly (({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}) | null)[] & CoList<({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | null>
organizations.
CoList<({ readonly name: string; readonly projects: CoList<({ readonly name: string; } & CoMap) | null> | null; } & CoMap) | null>.$jazz: CoListJazzApi<readonly (({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}) | null)[] & CoList<({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap) | null>>
$jazz.
CoListJazzApi<readonly (({ readonly name: string; readonly projects: CoList<({ readonly name: string; } & CoMap) | null> | null; } & CoMap & {}) | null)[] & CoList<({ readonly name: string; readonly projects: CoList<({ readonly name: string; } & CoMap) | null> | null; } & CoMap) | null>>.push(...items: (({
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap & {}) | CoMapInit<{
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & 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.@categoryContent
push(
organization: {
    readonly name: string;
    readonly projects: CoList<({
        readonly name: string;
    } & CoMap) | null> | null;
} & CoMap
organization);
        }
      });
    }
  };

  
useAcceptInvite<co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>>({ invitedObjectSchema, onAccept, forValueHint, }: {
    ...;
}): void
useAcceptInvite({
    
invitedObjectSchema: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
invitedObjectSchema: 
const Organization: co.Map<{
    name: z.z.ZodString;
    projects: co.List<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>
Organization,
    onAccept: (valueID: string) => voidonAccept,
  });

  return <React.JSX.IntrinsicElements.p: React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>p>Accepting invite...</React.JSX.IntrinsicElements.p: React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>p>;
}

Further reading

GitHubDocs issue?⌝DiscordJoin Discord⌝
Forms
History Patterns