Subscriptions & Deep Loading

const 
const Task: co.Map<{
    title: z.z.ZodString;
    description: z.z.ZodString;
    status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
    assignedTo: z.ZodOptional<z.z.ZodString>;
}, unknown, Account | Group>Task = import coco.
map<{
    title: z.z.ZodString;
    description: z.z.ZodString;
    status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
    assignedTo: z.ZodOptional<z.z.ZodString>;
}>(shape: {
    title: z.z.ZodString;
    description: z.z.ZodString;
    status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
    assignedTo: z.ZodOptional<z.z.ZodString>;
}): co.Map<...>
export mapmap({
  title: z.z.ZodStringtitle: import zz.
function string(params?: string | z.z.core.$ZodStringParams): z.z.ZodString (+1 overload)
export stringstring(),
  description: z.z.ZodStringdescription: import zz.
function string(params?: string | z.z.core.$ZodStringParams): z.z.ZodString (+1 overload)
export stringstring(),
  status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">status: import zz.
literal<readonly ["todo", "in-progress", "completed"]>(value: readonly ["todo", "in-progress", "completed"], params?: string | z.z.core.$ZodLiteralParams): z.z.ZodLiteral<"todo" | "in-progress" | "completed"> (+1 overload)
export literalliteral(["todo", "in-progress", "completed"]),
  assignedTo: z.ZodOptional<z.z.ZodString>assignedTo: import zz.
optional<z.z.ZodString>(innerType: z.z.ZodString): z.ZodOptional<z.z.ZodString>
export optionaloptional(import zz.
function string(params?: string | z.z.core.$ZodStringParams): z.z.ZodString (+1 overload)
export stringstring()),
});

// ...

// Subscribe to a Task by ID
const const unsubscribe: () => voidunsubscribe = 
const Task: co.Map<{
    title: z.z.ZodString;
    description: z.z.ZodString;
    status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
    assignedTo: z.ZodOptional<z.z.ZodString>;
}, unknown, Account | Group>Task.
CoMapSchema<{ title: ZodString; description: ZodString; status: ZodLiteral<"todo" | "in-progress" | "completed">; assignedTo: ZodOptional<ZodString>; }, unknown, Account | Group>.subscribe<true>(id: string, options: SubscribeListenerOptions<{
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMap, true>, listener: (value: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMap, unsubscribe: () => void) => void): () => voidsubscribe(const taskId: "co_123"taskId, {}, (
updatedTask: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMapupdatedTask) => {
  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("Task updated:", 
updatedTask: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMapupdatedTask.title: stringtitle);
  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("New status:", 
updatedTask: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMapupdatedTask.status: "todo" | "in-progress" | "completed"status);
});

// Clean up when you're done
const unsubscribe: () => voidunsubscribe();

const 
const task: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMaptask = 
const Task: co.Map<{
    title: z.z.ZodString;
    description: z.z.ZodString;
    status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
    assignedTo: z.ZodOptional<z.z.ZodString>;
}, unknown, Account | Group>Task.
CoMapSchema<{ title: ZodString; description: ZodString; status: ZodLiteral<"todo" | "in-progress" | "completed">; assignedTo: ZodOptional<ZodString>; }, unknown, Account | Group>.create: (init: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo?: string | undefined;
}, options?: Account | Group | {
    owner: Account | Group;
    unique?: CoValueUniqueness["uniqueness"];
} | undefined) => {
    ...;
} & CoMapcreate({
  title: stringtitle: "Cut the grass",
  ...const otherProps: anyotherProps
});

const const unsubscribe: () => voidunsubscribe = 
const task: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMaptask.
CoMap.subscribe<{
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMap, true>(this: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMap, listener: (value: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMap, unsubscribe: () => void) => void): () => void (+1 overload)
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.
@categorySubscription & Loadingsubscribe((
updatedTask: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMapupdatedTask) => {
  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("Task updated:", 
updatedTask: {
    title: string;
    description: string;
    status: "todo" | "in-progress" | "completed";
    assignedTo: string | undefined;
} & CoMapupdatedTask.title: stringtitle);
});

// Clean up when you're done
const unsubscribe: () => voidunsubscribe();

import { 
function useCoState<S extends CoValueClassOrSchema, const R extends ResolveQuery<S> = true>(Schema: S, id: string | undefined, options?: {
    resolve?: ResolveQueryStrict<S, R>;
}): co.loaded<S, R> | undefined | null
React hook for subscribing to CoValues and handling loading states.

This hook provides a convenient way to subscribe to CoValues and automatically
handles the subscription lifecycle (subscribe on mount, unsubscribe on unmount).
It also supports deep loading of nested CoValues through resolve queries.
@returnsThe loaded CoValue, or `undefined` if loading, or `null` if not found/not accessible@example```tsx
// Deep loading with resolve queries
const Project = co.map({
  name: z.string(),
  tasks: co.list(Task),
  owner: TeamMember,
});

function ProjectView({ projectId }: { projectId: string }) {
  const project = useCoState(Project, projectId, {
    resolve: {
      tasks: { $each: true },
      owner: true,
    },
  });

  if (!project) {
    return project === null
      ? "Project not found or not accessible"
      : "Loading project...";
  }

  return (
    <div>
      <h1>{project.name}</h1>
      <p>Owner: {project.owner.name}</p>
      <ul>
        {project.tasks.map((task) => (
          <li key={task.id}>{task.title}</li>
        ))}
      </ul>
    </div>
  );
}
```@example```tsx
// Using with optional references and error handling
const Task = co.map({
  title: z.string(),
  assignee: co.optional(TeamMember),
  subtasks: co.list(Task),
});

function TaskDetail({ taskId }: { taskId: string }) {
  const task = useCoState(Task, taskId, {
    resolve: {
      assignee: true,
      subtasks: { $each: { $onError: null } },
    },
  });

  if (!task) {
    return task === null
      ? "Task not found or not accessible"
      : "Loading task...";
  }

  return (
    <div>
      <h2>{task.title}</h2>
      {task.assignee && <p>Assigned to: {task.assignee.name}</p>}
      <ul>
        {task.subtasks.map((subtask, index) => (
          subtask ? <li key={subtask.id}>{subtask.title}</li> : <li key={index}>Inaccessible subtask</li>
        ))}
      </ul>
    </div>
  );
}
```

For more examples, see the [subscription and deep loading](https://jazz.tools/docs/react/using-covalues/subscription-and-loading) documentation.useCoState } from "jazz-tools/react";

function 
function GardenPlanner({ projectId }: {
    projectId: string;
}): "Project not found or not accessible" | "Loading project ..." | React.JSX.ElementGardenPlanner({ projectId: stringprojectId }: { projectId: stringprojectId: string }) {
  // Subscribe to a project and its tasks
  const 
const project: ({
    tasks: ({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap)[] & CoList<({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap) | null>;
} & {
    ...;
} & CoMap) | null | undefinedproject = 
useCoState<co.Map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>, {
    ...;
}>(Schema: co.Map<...>, id: string | undefined, options?: {
    ...;
} | undefined): ({
    ...;
} & ... 1 more ... & CoMap) | ... 1 more ... | undefined
React hook for subscribing to CoValues and handling loading states.

This hook provides a convenient way to subscribe to CoValues and automatically
handles the subscription lifecycle (subscribe on mount, unsubscribe on unmount).
It also supports deep loading of nested CoValues through resolve queries.
@returnsThe loaded CoValue, or `undefined` if loading, or `null` if not found/not accessible@example```tsx
// Deep loading with resolve queries
const Project = co.map({
  name: z.string(),
  tasks: co.list(Task),
  owner: TeamMember,
});

function ProjectView({ projectId }: { projectId: string }) {
  const project = useCoState(Project, projectId, {
    resolve: {
      tasks: { $each: true },
      owner: true,
    },
  });

  if (!project) {
    return project === null
      ? "Project not found or not accessible"
      : "Loading project...";
  }

  return (
    <div>
      <h1>{project.name}</h1>
      <p>Owner: {project.owner.name}</p>
      <ul>
        {project.tasks.map((task) => (
          <li key={task.id}>{task.title}</li>
        ))}
      </ul>
    </div>
  );
}
```@example```tsx
// Using with optional references and error handling
const Task = co.map({
  title: z.string(),
  assignee: co.optional(TeamMember),
  subtasks: co.list(Task),
});

function TaskDetail({ taskId }: { taskId: string }) {
  const task = useCoState(Task, taskId, {
    resolve: {
      assignee: true,
      subtasks: { $each: { $onError: null } },
    },
  });

  if (!task) {
    return task === null
      ? "Task not found or not accessible"
      : "Loading task...";
  }

  return (
    <div>
      <h2>{task.title}</h2>
      {task.assignee && <p>Assigned to: {task.assignee.name}</p>}
      <ul>
        {task.subtasks.map((subtask, index) => (
          subtask ? <li key={subtask.id}>{subtask.title}</li> : <li key={index}>Inaccessible subtask</li>
        ))}
      </ul>
    </div>
  );
}
```

For more examples, see the [subscription and deep loading](https://jazz.tools/docs/react/using-covalues/subscription-and-loading) documentation.useCoState(
const Project: co.Map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
    }, unknown, Account | Group>>;
}, unknown, Account | Group>Project, projectId: stringprojectId, {
    
resolve?: RefsToResolve<{
    ...;
} & CoMap, 10, []> | undefined
Resolve query to specify which nested CoValues to loadresolve: {
      
tasks?: RefsToResolve<CoList<({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap) | null>, 10, [0]> | undefinedtasks: { 
$each: RefsToResolve<{
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap, 10, [0, 0]>$each: true },
    },
  });

  if (!
const project: ({
    tasks: ({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap)[] & CoList<({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap) | null>;
} & {
    ...;
} & CoMap) | null | undefinedproject) {
    return const project: null | undefinedproject === null
      ? "Project not found or not accessible"
      : "Loading project ...";
  }

  return (
    <React.JSX.IntrinsicElements.div: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>div>
      <React.JSX.IntrinsicElements.h1: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>h1>{
const project: {
    tasks: ({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap)[] & CoList<({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap) | null>;
} & {
    ...;
} & CoMapproject.name: stringname}</React.JSX.IntrinsicElements.h1: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>h1>
      <
function TaskList({ tasks }: {
    tasks: co.loaded<typeof Task>[];
}): React.JSX.ElementTaskList 
tasks: ({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap)[]tasks={
const project: {
    tasks: ({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap)[] & CoList<({
        title: string;
        status: "todo" | "in-progress" | "completed";
    } & CoMap) | null>;
} & {
    ...;
} & CoMapproject.
tasks: ({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap)[] & CoList<({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap) | null>tasks} />
    </React.JSX.IntrinsicElements.div: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>div>
  );
}

function 
function TaskList({ tasks }: {
    tasks: co.loaded<typeof Task>[];
}): React.JSX.ElementTaskList({ 
tasks: ({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap)[]tasks }: { 
tasks: ({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap)[]tasks: 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 {
    ...;
} ? ((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 loadedloaded<typeof 
const Task: co.Map<{
    title: z.z.ZodString;
    status: z.z.ZodLiteral<"todo" | "in-progress" | "completed">;
}, unknown, Account | Group>Task>[] }) {
  return (
    <React.JSX.IntrinsicElements.ul: React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>ul>
      {
tasks: ({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap)[]tasks.
Array<{ title: string; status: "todo" | "in-progress" | "completed"; } & CoMap>.map<React.JSX.Element>(callbackfn: (value: {
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap, index: number, array: ({
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMap)[]) => React.JSX.Element, thisArg?: any): React.JSX.Element[]
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((
task: {
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMaptask) => (
        <React.JSX.IntrinsicElements.li: React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>li React.Attributes.key?: React.Key | null | undefinedkey={
task: {
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMaptask.CoMap.id: string
The ID of this `CoMap`
@categoryContentid}>
          <React.JSX.IntrinsicElements.span: React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>span>{
task: {
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMaptask.title: stringtitle}</React.JSX.IntrinsicElements.span: React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>span>
          <React.JSX.IntrinsicElements.span: React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>span>{
task: {
    title: string;
    status: "todo" | "in-progress" | "completed";
} & CoMaptask.status: "todo" | "in-progress" | "completed"status}</React.JSX.IntrinsicElements.span: React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>span>
        </React.JSX.IntrinsicElements.li: React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>li>
      ))}
    </React.JSX.IntrinsicElements.ul: React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>ul>
  );
}

import { 
function useAccount<A extends AccountClass<Account> | CoreAccountSchema, R extends ResolveQuery<A> = true>(AccountSchema?: A, options?: {
    resolve?: ResolveQueryStrict<A, R>;
}): {
    me: co.loaded<A, R> | undefined | null;
    agent: AnonymousJazzAgent | co.loaded<A, true>;
    logOut: () => void;
}
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 } from "jazz-tools/react";

function function ProjectList(): React.JSX.ElementProjectList() {
  const { 
const me: ({
    profile: {
        name: string;
        inbox: string | undefined;
        inboxInvite: string | undefined;
    } & CoMap & Profile;
    root: {
        myProjects: ({
            name: string;
            tasks: CoList<({
                ...;
            } & CoMap) | null> | null;
        } & CoMap & {
            ...;
        })[] & CoList<...>;
    } & {
        ...;
    } & CoMap;
} & {
    ...;
} & Account) | null | undefinedme } = 
useAccount<co.Account<{
    root: co.Map<{
        myProjects: co.List<co.Map<{
            name: z.z.ZodString;
            tasks: co.List<co.Map<{
                title: 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 MyAppAccount: co.Account<{
    root: co.Map<{
        myProjects: co.List<co.Map<{
            name: z.z.ZodString;
            tasks: co.List<co.Map<{
                title: z.z.ZodString;
            }, unknown, Account | Group>>;
        }, unknown, Account | Group>>;
    }, unknown, Account | Group>;
    profile: co.Profile<...>;
}>MyAppAccount, {
    
resolve?: RefsToResolve<{
    ...;
} & Account, 10, []> | undefined
Resolve query to specify which nested CoValues to load from the accountresolve: {
      
profile?: RefsToResolve<{
    name: string;
    inbox: string | undefined;
    inboxInvite: string | undefined;
} & CoMap & Profile, 10, [0]> | undefinedprofile: true,
      
root?: RefsToResolve<{
    myProjects: CoList<...> | null;
} & CoMap, 10, [...]> | undefinedroot: {
        
myProjects?: RefsToResolve<CoList<({
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap) | null>, 10, [...]> | undefinedmyProjects: {
          
$each: RefsToResolve<{
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap, 10, [...]>$each: {
            
tasks?: RefsToResolve<CoList<({
    title: string;
} & CoMap) | null>, 10, [0, 0, 0, 0]> | undefinedtasks: true,
          },
        },
      },
    },
  });

  if (!
const me: ({
    profile: {
        name: string;
        inbox: string | undefined;
        inboxInvite: string | undefined;
    } & CoMap & Profile;
    root: {
        myProjects: ({
            name: string;
            tasks: CoList<({
                ...;
            } & CoMap) | null> | null;
        } & CoMap & {
            ...;
        })[] & CoList<...>;
    } & {
        ...;
    } & CoMap;
} & {
    ...;
} & Account) | null | undefinedme) {
    return <React.JSX.IntrinsicElements.div: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>div>Loading...</React.JSX.IntrinsicElements.div: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>div>;
  }

  return (
    <React.JSX.IntrinsicElements.div: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>div>
      <React.JSX.IntrinsicElements.h1: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>h1>{
const me: {
    profile: {
        name: string;
        inbox: string | undefined;
        inboxInvite: string | undefined;
    } & CoMap & Profile;
    root: {
        myProjects: ({
            name: string;
            tasks: CoList<({
                ...;
            } & CoMap) | null> | null;
        } & CoMap & {
            ...;
        })[] & CoList<...>;
    } & {
        ...;
    } & CoMap;
} & {
    ...;
} & Accountme.
Account.profile: {
    name: string;
    inbox: string | undefined;
    inboxInvite: string | undefined;
} & CoMap & Profileprofile.Profile.name: stringname}'s projects</React.JSX.IntrinsicElements.h1: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>h1>
      <React.JSX.IntrinsicElements.ul: React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>ul>
        {
const me: {
    profile: {
        name: string;
        inbox: string | undefined;
        inboxInvite: string | undefined;
    } & CoMap & Profile;
    root: {
        myProjects: ({
            name: string;
            tasks: CoList<({
                ...;
            } & CoMap) | null> | null;
        } & CoMap & {
            ...;
        })[] & CoList<...>;
    } & {
        ...;
    } & CoMap;
} & {
    ...;
} & Accountme.
Account.root: {
    myProjects: ({
        name: string;
        tasks: CoList<({
            ...;
        } & CoMap) | null> | null;
    } & CoMap & {
        ...;
    })[] & CoList<...>;
} & {
    myProjects: CoList<...> | null;
} & CoMaproot.
myProjects: ({
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap & {
    ...;
})[] & CoList<({
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap) | null>myProjects.
Array<T>.map<React.JSX.Element>(callbackfn: (value: {
    name: string;
    tasks: CoList<({
        title: string;
    } & CoMap) | null> | null;
} & CoMap & {
    tasks: CoList<({
        title: string;
    } & CoMap) | null>;
}, index: number, array: ({
    name: string;
    tasks: CoList<({
        title: string;
    } & CoMap) | null> | null;
} & ... 1 more ... & {
    tasks: CoList<({
        title: string;
    } & CoMap) | null>;
})[]) => React.JSX.Element, thisArg?: any): React.JSX.Element[] (+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((
project: {
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap & {
    ...;
}project) => (
          <React.JSX.IntrinsicElements.li: React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>li React.Attributes.key?: React.Key | null | undefinedkey={
project: {
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap & {
    ...;
}project.CoMap.id: string
The ID of this `CoMap`
@categoryContentid}>
            {
project: {
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap & {
    ...;
}project.name: stringname} ({
project: {
    name: string;
    tasks: CoList<({
        ...;
    } & CoMap) | null> | null;
} & CoMap & {
    ...;
}project.
tasks: CoList<({
    title: string;
} & CoMap) | null>tasks.Array<T>.length: number
Gets or sets the length of the array. This is a number one higher than the highest index in the array.length} tasks)
          </React.JSX.IntrinsicElements.li: React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>li>
        ))}
      </React.JSX.IntrinsicElements.ul: React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>ul>
    </React.JSX.IntrinsicElements.div: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>div>
  );
}

const Task: co.Map<{
    title: z.z.ZodString;
}, unknown, Account | Group>Task.
CoMapSchema<{ title: ZodString; }, unknown, Account | Group>.subscribe<true>(id: string, options: SubscribeListenerOptions<{
    title: string;
} & CoMap, true>, listener: (value: {
    title: string;
} & CoMap, unsubscribe: () => void) => void): () => voidsubscribe(const taskId: "co_123"taskId, {}, (
task: {
    title: string;
} & CoMaptask: 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 {
    ...;
} ? ((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 loadedloaded<typeof 
const Task: co.Map<{
    title: z.z.ZodString;
}, unknown, Account | Group>Task>) => {
  if (
task: {
    title: string;
} & CoMaptask === var undefinedundefined) {
    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("Task is loading...");
  } else if (
task: {
    title: string;
} & CoMaptask === null) {
    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("Task not found or not accessible");
  } else {
    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("Task loaded:", 
task: {
    title: string;
} & CoMaptask.title: stringtitle);
  }
});

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

const 
const Task: co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>Task = import coco.
map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}>(shape: {
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}): co.Map<...>
export mapmap({
  title: z.z.ZodStringtitle: import zz.
function string(params?: string | z.z.core.$ZodStringParams): z.z.ZodString (+1 overload)
export stringstring(),
  
assignee: co.Optional<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>assignee: import coco.
optional<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>(schema: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>): co.Optional<co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>>
export optionaloptional(
const TeamMember: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>TeamMember),
  get 
subtasks: co.List<co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>>subtasks(): import coco.
class List<T extends AnyZodOrCoValueSchema>
export ListList<typeof 
const Task: co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>Task> { return import coco.
list<co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>>(element: co.Map<...>): co.List<...>
export listlist(
const Task: co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>Task) },
});

const 
const Project: co.Map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        assignee: co.Optional<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
        readonly subtasks: co.List<typeof Task>;
    }, unknown, Account | Group>>;
    owner: co.Map<...>;
}, unknown, Account | Group>Project = import coco.
map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        assignee: co.Optional<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
        readonly subtasks: co.List<typeof Task>;
    }, unknown, Account | Group>>;
    owner: co.Map<...>;
}>(shape: {
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        assignee: co.Optional<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
        readonly subtasks: co.List<typeof Task>;
    }, unknown, Account | Group>>;
    owner: co.Map<...>;
}): co.Map<...>
export mapmap({
  name: z.z.ZodStringname: import zz.
function string(params?: string | z.z.core.$ZodStringParams): z.z.ZodString (+1 overload)
export stringstring(),
  
tasks: co.List<co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>>tasks: import coco.
list<co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>>(element: co.Map<...>): co.List<...>
export listlist(
const Task: co.Map<{
    title: z.z.ZodString;
    assignee: co.Optional<co.Map<{
        name: z.z.ZodString;
    }, unknown, Account | Group>>;
    readonly subtasks: co.List<typeof Task>;
}, unknown, Account | Group>Task),
  
owner: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>owner: 
const TeamMember: co.Map<{
    name: z.z.ZodString;
}, unknown, Account | Group>TeamMember,
});

// Load just the project, not its references
const 
const project: ({
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullproject = await 
const Project: co.Map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        assignee: co.Optional<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
        readonly subtasks: co.List<typeof Task>;
    }, unknown, Account | Group>>;
    owner: co.Map<...>;
}, unknown, Account | Group>Project.
CoMapSchema<{ name: ZodString; tasks: CoListSchema<CoMapSchema<{ title: ZodString; assignee: CoOptionalSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; readonly subtasks: co.List<typeof Task>; }, unknown, Account | Group>>; owner: CoMapSchema<...>; }, unknown, Account | Group>.load<true>(id: string, options?: {
    resolve?: RefsToResolve<{
        name: string;
        tasks: CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null> | null;
        owner: ({
            name: string;
        } & CoMap) | null;
    } & CoMap, 10, []> | undefined;
    loadAs?: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
} | undefined): Promise<...>load(const projectId: "co_123"projectId);
if (!
const project: ({
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullproject) { throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error("Project not found or not accessible"); }

// string - primitive fields are always loaded
const project: {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapproject.name: stringname;
// undefined | null | ListOfTasks - non-requested references might not be loaded, or inaccessible
const project: {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapproject.
tasks: CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null> | nulltasks;

// Load the project and shallowly load its list of tasks
const 
const projectWithTasksShallow: ({
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullprojectWithTasksShallow = await 
const Project: co.Map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        assignee: co.Optional<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
        readonly subtasks: co.List<typeof Task>;
    }, unknown, Account | Group>>;
    owner: co.Map<...>;
}, unknown, Account | Group>Project.
CoMapSchema<{ name: ZodString; tasks: CoListSchema<CoMapSchema<{ title: ZodString; assignee: CoOptionalSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; readonly subtasks: co.List<typeof Task>; }, unknown, Account | Group>>; owner: CoMapSchema<...>; }, unknown, Account | Group>.load<{
    tasks: true;
}>(id: string, options?: {
    resolve?: RefsToResolve<{
        name: string;
        tasks: CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null> | null;
        owner: ({
            name: string;
        } & CoMap) | null;
    } & CoMap, 10, []> | undefined;
    loadAs?: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
} | undefined): Promise<...>load(const projectId: "co_123"projectId, {
  
resolve?: RefsToResolve<{
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap, 10, []> | undefinedresolve: {
    
tasks?: RefsToResolve<CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>, 10, [0]> | undefinedtasks: true
  }
});
if (!
const projectWithTasksShallow: ({
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullprojectWithTasksShallow) { throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error("Project or required references not found or not accessible"); }

// ListOfTasks - shallowly loaded
const projectWithTasksShallow: {
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectWithTasksShallow.
tasks: CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks;
// number - length of the list
const projectWithTasksShallow: {
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectWithTasksShallow.
tasks: CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks.Array<T>.length: number
Gets or sets the length of the array. This is a number one higher than the highest index in the array.length;
// undefined | null | Task - items might not be loaded, or inaccessible
const projectWithTasksShallow: {
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectWithTasksShallow.
tasks: CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks[0];

// Load the project and its tasks
const 
const projectWithTasks: ({
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullprojectWithTasks = await 
const Project: co.Map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        assignee: co.Optional<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
        readonly subtasks: co.List<typeof Task>;
    }, unknown, Account | Group>>;
    owner: co.Map<...>;
}, unknown, Account | Group>Project.
CoMapSchema<{ name: ZodString; tasks: CoListSchema<CoMapSchema<{ title: ZodString; assignee: CoOptionalSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; readonly subtasks: co.List<typeof Task>; }, unknown, Account | Group>>; owner: CoMapSchema<...>; }, unknown, Account | Group>.load<{
    tasks: {
        $each: true;
    };
}>(id: string, options?: {
    resolve?: RefsToResolve<{
        name: string;
        tasks: CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null> | null;
        owner: ({
            name: string;
        } & CoMap) | null;
    } & CoMap, 10, []> | undefined;
    loadAs?: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
} | undefined): Promise<...>load(const projectId: "co_123"projectId, {
  
resolve?: RefsToResolve<{
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap, 10, []> | undefinedresolve: {
    
tasks?: RefsToResolve<CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>, 10, [0]> | undefinedtasks: {
      
$each: RefsToResolve<{
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap, 10, [0, 0]>$each: true
    }
  }
});
if (!
const projectWithTasks: ({
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullprojectWithTasks) { throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error("Project or required references not found or not accessible"); }

// ListOfTasks - fully loaded
const projectWithTasks: {
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectWithTasks.
tasks: ({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap)[] & CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks;
// Task - fully loaded
const projectWithTasks: {
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectWithTasks.
tasks: ({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap)[] & CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks[0];
// string - primitive fields are always loaded
const projectWithTasks: {
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectWithTasks.
tasks: ({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap)[] & CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks[0].title: stringtitle;
// undefined | null | ListOfTasks - subtasks might not be loaded, or inaccessible
const projectWithTasks: {
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectWithTasks.
tasks: ({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap)[] & CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks[0].
subtasks: CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null> | nullsubtasks;

// Load the project, its tasks, and their subtasks
const 
const projectDeep: ({
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap & {
        subtasks: ({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap)[] & CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null>;
        assignee: ({
            name: string;
        } & CoMap) | undefined;
    })[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullprojectDeep = await 
const Project: co.Map<{
    name: z.z.ZodString;
    tasks: co.List<co.Map<{
        title: z.z.ZodString;
        assignee: co.Optional<co.Map<{
            name: z.z.ZodString;
        }, unknown, Account | Group>>;
        readonly subtasks: co.List<typeof Task>;
    }, unknown, Account | Group>>;
    owner: co.Map<...>;
}, unknown, Account | Group>Project.
CoMapSchema<{ name: ZodString; tasks: CoListSchema<CoMapSchema<{ title: ZodString; assignee: CoOptionalSchema<CoMapSchema<{ name: ZodString; }, unknown, Account | Group>>; readonly subtasks: co.List<typeof Task>; }, unknown, Account | Group>>; owner: CoMapSchema<...>; }, unknown, Account | Group>.load<{
    tasks: {
        $each: {
            subtasks: {
                $each: true;
            };
            assignee: true;
        };
    };
}>(id: string, options?: {
    resolve?: RefsToResolve<{
        name: string;
        tasks: CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null> | null;
        owner: ({
            name: string;
        } & CoMap) | null;
    } & CoMap, 10, []> | undefined;
    loadAs?: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
} | undefined): Promise<...>load(const projectId: "co_123"projectId, {
  
resolve?: RefsToResolve<{
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap, 10, []> | undefinedresolve: {
    
tasks?: RefsToResolve<CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>, 10, [0]> | undefinedtasks: {
      
$each: RefsToResolve<{
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap, 10, [0, 0]>$each: {
        
subtasks?: RefsToResolve<CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>, 10, [0, 0, 0]> | undefinedsubtasks: {
          
$each: RefsToResolve<{
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap, 10, [0, 0, 0, 0]>$each: true
        },
        
assignee?: RefsToResolve<{
    name: string;
} & CoMap, 10, [0, 0, 0]> | undefinedassignee: true
      }
    }
  }
});
if (!
const projectDeep: ({
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap & {
        subtasks: ({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap)[] & CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null>;
        assignee: ({
            name: string;
        } & CoMap) | undefined;
    })[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMap) | nullprojectDeep) { throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error("Project or required references not found or not accessible"); }

// string - primitive fields are always loaded
const projectDeep: {
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap & {
        subtasks: ({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap)[] & CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null>;
        assignee: ({
            name: string;
        } & CoMap) | undefined;
    })[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectDeep.
tasks: ({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap & {
    subtasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
    assignee: ({
        name: string;
    } & CoMap) | undefined;
})[] & CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks[0].
subtasks: CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null> & ({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap)[]subtasks[0].title: stringtitle;
// undefined | null | TeamMember - since assignee is optional:
//   TeamMember - set and definitely loaded
//   null - set but unavailable/inaccessible
//   undefined - not set, or loading (in case of subscription)
const projectDeep: {
    tasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap & {
        subtasks: ({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap)[] & CoList<({
            title: string;
            assignee: ({
                name: string;
            } & CoMap) | null | undefined;
            subtasks: co.List<typeof Task>;
        } & CoMap) | null>;
        assignee: ({
            name: string;
        } & CoMap) | undefined;
    })[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
} & {
    name: string;
    tasks: CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null> | null;
    owner: ({
        name: string;
    } & CoMap) | null;
} & CoMapprojectDeep.
tasks: ({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap & {
    subtasks: ({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap)[] & CoList<({
        title: string;
        assignee: ({
            name: string;
        } & CoMap) | null | undefined;
        subtasks: co.List<typeof Task>;
    } & CoMap) | null>;
    assignee: ({
        name: string;
    } & CoMap) | undefined;
})[] & CoList<({
    title: string;
    assignee: ({
        name: string;
    } & CoMap) | null | undefined;
    subtasks: co.List<typeof Task>;
} & CoMap) | null>tasks[0].
assignee: ({
    name: string;
} & CoMap) | undefinedassignee;