jazz-tools 0.17.14 → 0.18.1

package/src/tools/coValues/profile.ts

@@ -1,18 +1,19 @@
 import {
   Account,
   CoMap,
-  CoMapInit,
+  CoMapInit_DEPRECATED,
   CoValueClass,
   Group,
   Simplify,
+  TypeSym,
   coField,
 } from "../internal.js";
 
 /** @category Identity & Permissions */
 export class Profile extends CoMap {
-  name = coField.string;
-  inbox? = coField.optional.string;
-  inboxInvite? = coField.optional.string;
+  readonly name = coField.string;
+  readonly inbox? = coField.optional.string;
+  readonly inboxInvite? = coField.optional.string;
 
   /**
    * Creates a new profile with the given initial values and owner.
@@ -20,10 +21,11 @@ export class Profile extends CoMap {
    * The owner (a Group) determines access rights to the Profile.
    *
    * @category Creation
+   * @deprecated Use `co.profile(...).create` instead.
    */
   static override create<M extends CoMap>(
     this: CoValueClass<M>,
-    init: Simplify<CoMapInit<M>>,
+    init: Simplify<CoMapInit_DEPRECATED<M>>,
     options?:
       | {
           owner: Group;
@@ -34,7 +36,7 @@ export class Profile extends CoMap {
       options !== undefined && "owner" in options ? options.owner : options;
 
     // We add some guardrails to ensure that the owner of a profile is a group
-    if ((owner as Group | Account | undefined)?._type === "Account") {
+    if ((owner as Group | Account | undefined)?.[TypeSym] === "Account") {
       throw new Error("Profiles should be owned by a group");
     }
 

package/src/tools/coValues/request.ts

@@ -136,7 +136,7 @@ async function serializeMessagePayload({
   target: Account | Group;
 }) {
   const me = owner ?? Account.getMe();
-  const node = me._raw.core.node;
+  const node = me.$jazz.localNode;
   const crypto = node.crypto;
 
   const agent = node.getCurrentAgent();
@@ -146,7 +146,7 @@ async function serializeMessagePayload({
   const envelope = createMessageEnvelope(schema, value, me, target, type);
 
   const contentPieces =
-    (await exportCoValue(schema, envelope.id, {
+    (await exportCoValue(schema, envelope.$jazz.id, {
       resolve,
       loadAs: me,
       bestEffortResolution: true,
@@ -156,7 +156,7 @@ async function serializeMessagePayload({
 
   const signPayload = crypto.secureHash({
     contentPieces,
-    id: envelope.id,
+    id: envelope.$jazz.id,
     createdAt,
     signerID,
   });
@@ -165,7 +165,7 @@ async function serializeMessagePayload({
 
   return {
     contentPieces,
-    id: envelope.id,
+    id: envelope.$jazz.id,
     createdAt,
     authToken,
     signerID,
@@ -203,7 +203,7 @@ async function handleMessagePayload({
   request: unknown;
   loadAs: Account;
 }) {
-  const node = loadAs._raw.core.node;
+  const node = loadAs.$jazz.localNode;
   const crypto = node.crypto;
 
   const requestParsed = requestSchema.safeParse(request);
@@ -225,7 +225,7 @@ async function handleMessagePayload({
     if (core.isAvailable()) {
       const content = core.getCurrentContent() as RawCoMap;
 
-      if (content.get("$handled") === loadAs.id) {
+      if (content.get("$handled") === loadAs.$jazz.id) {
         throw new JazzRequestError("Request payload is already handled", 400);
       }
     }
@@ -303,7 +303,7 @@ async function handleMessagePayload({
   }
 
   if (type === "request") {
-    value._raw.set("$handled", loadAs.id);
+    value.$jazz.raw.set("$handled", loadAs.$jazz.id);
   }
 
   return {
@@ -469,7 +469,7 @@ export class HttpRoute<
       | Promise<MessageValuePayload<ResponseShape>>
       | MessageValuePayload<ResponseShape>,
   ): Promise<Response> => {
-    const node = as._raw.core.node;
+    const node = as.$jazz.localNode;
     const body = await request.json();
     const data = await handleMessagePayload({
       type: "request",
@@ -612,7 +612,7 @@ function safeVerifySignature(
 }
 
 async function loadWorkerAccountOrGroup(id: string, loadAs: Account) {
-  const node = loadAs._raw.core.node;
+  const node = loadAs.$jazz.localNode;
   const coValue = await node.loadCoValueCore(id as `co_z${string}`);
 
   if (!coValue.isAvailable()) {

package/src/tools/coValues/schemaUnion.ts

@@ -2,11 +2,12 @@ import { JsonValue, RawCoMap } from "cojson";
 import {
   Account,
   AnonymousJazzAgent,
-  CoMapInit,
+  CoMapInit_DEPRECATED,
   CoValue,
   CoValueBase,
   CoValueClass,
   CoValueFromRaw,
+  CoValueJazzApi,
   Group,
   ID,
   Resolved,
@@ -100,9 +101,11 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
     discriminator: SchemaUnionDiscriminator<V>,
   ): SchemaUnionConcreteSubclass<V> {
     return class SchemaUnionClass extends SchemaUnion {
+      declare $jazz: CoValueJazzApi<this>;
+
       static override create<V extends CoValue>(
         this: CoValueClass<V>,
-        init: Simplify<CoMapInit<V>>,
+        init: Simplify<CoMapInit_DEPRECATED<V>>,
         owner: Account | Group,
       ): V {
         const ResolvedClass = discriminator(new Map(Object.entries(init)));
@@ -112,7 +115,7 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
 
       static override fromRaw<T extends CoValue>(
         this: CoValueClass<T> & CoValueFromRaw<T>,
-        raw: T["_raw"],
+        raw: T["$jazz"]["raw"],
       ): T {
         const ResolvedClass = discriminator(
           raw as RawCoMap,
@@ -124,7 +127,7 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
 
   static create<V extends CoValue>(
     this: CoValueClass<V>,
-    init: Simplify<CoMapInit<V>>,
+    init: Simplify<CoMapInit_DEPRECATED<V>>,
     owner: Account | Group,
   ): V {
     throw new Error("Not implemented");
@@ -136,7 +139,10 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
    *
    * @internal
    */
-  static fromRaw<V extends CoValue>(this: CoValueClass<V>, raw: V["_raw"]): V {
+  static fromRaw<V extends CoValue>(
+    this: CoValueClass<V>,
+    raw: V["$jazz"]["raw"],
+  ): V {
     throw new Error("Not implemented");
   }
 

package/src/tools/exports.ts

@@ -30,7 +30,7 @@ export type {
   Resolved,
   RefsToResolve,
   RefsToResolveStrict,
-  CoMapInit,
+  CoMapInit_DEPRECATED as CoMapInit,
   CoFeedEntry,
   TextPos,
   AccountClass,

package/src/tools/implementation/ContextManager.ts

@@ -247,7 +247,7 @@ export class JazzContextManager<
     }
 
     if (this.context && "me" in this.context) {
-      return this.context.me.id;
+      return this.context.me.$jazz.id;
     }
 
     throw new Error("The registration hasn't created a new account");
@@ -271,8 +271,8 @@ export class JazzContextManager<
       // Using a direct connection to make coValue transfer almost synchronous
       const [prevAccountAsPeer, currentAccountAsPeer] =
         cojsonInternals.connectedPeers(
-          prevContext.me.id,
-          currentContext.me.id,
+          prevContext.me.$jazz.id,
+          currentContext.me.$jazz.id,
           {
             peer1role: "client",
             peer2role: "server",
@@ -288,7 +288,7 @@ export class JazzContextManager<
 
       try {
         await this.props.onAnonymousAccountDiscarded?.(prevContext.me);
-        await prevContext.me.waitForAllCoValuesSync();
+        await prevContext.me.$jazz.waitForAllCoValuesSync();
       } catch (error) {
         console.error("Error onAnonymousAccountDiscarded", error);
       }

package/src/tools/implementation/anonymousJazzAgent.ts

@@ -1,6 +1,7 @@
 import { LocalNode } from "cojson";
+import { TypeSym } from "./symbols";
 
 export class AnonymousJazzAgent {
-  _type = "Anonymous" as const;
+  [TypeSym] = "Anonymous" as const;
   constructor(public node: LocalNode) {}
 }

package/src/tools/implementation/createContext.ts

@@ -271,7 +271,7 @@ export async function createJazzContext<
 
     if (!options.newAccountProps) {
       await authSecretStorage.setWithoutNotify({
-        accountID: context.account.id,
+        accountID: context.account.$jazz.id,
         secretSeed,
         accountSecret: context.node.getCurrentAgent().agentSecret,
         provider: "anonymous",

package/src/tools/implementation/devtoolsFormatters.ts

@@ -1,19 +1,19 @@
 /* istanbul ignore file -- @preserve */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { ItemsSym } from "./symbols.js";
+import { ItemsSym, TypeSym } from "./symbols.js";
 
 (globalThis as any).devtoolsFormatters = [
   {
     header: (object: any) => {
-      if (object._type === "CoMap") {
+      if (object[TypeSym] === "CoMap") {
         return ["div", {}, ["span", {}, object.constructor.name]];
-      } else if (object._type === "CoList") {
+      } else if (object[TypeSym] === "CoList") {
         return [
           "div",
           {},
           ["span", {}, object.constructor.name + "(" + object.length + ") "],
         ];
-      } else if (object._type === "Account") {
+      } else if (object[TypeSym] === "Account") {
         return [
           "div",
           {},
@@ -22,7 +22,7 @@ import { ItemsSym } from "./symbols.js";
             {},
             object.constructor.name +
               "(" +
-              object._refs.profile.value?.name +
+              object.$jazz.refs.profile.value?.name +
               (object.isMe ? " ME" : "") +
               ")",
           ],
@@ -35,7 +35,7 @@ import { ItemsSym } from "./symbols.js";
       return true;
     },
     body: function (object: any) {
-      if (object._type === "CoMap" || object._type === "Account") {
+      if (object[TypeSym] === "CoMap" || object[TypeSym] === "Account") {
         return [
           "div",
           { style: "margin-left: 15px" },
@@ -52,7 +52,7 @@ import { ItemsSym } from "./symbols.js";
                       "span",
                       { style: "opacity: 0.5" },
                       ` (pending ${object._schema[k].name} `,
-                      ["object", { object: object._refs[k] }],
+                      ["object", { object: object.$jazz.refs[k] }],
                       ")",
                     ],
                   ]
@@ -60,7 +60,7 @@ import { ItemsSym } from "./symbols.js";
               : []),
           ]),
         ];
-      } else if (object._type === "CoList") {
+      } else if (object[TypeSym] === "CoList") {
         return [
           "div",
           { style: "margin-left: 15px" },
@@ -77,7 +77,7 @@ import { ItemsSym } from "./symbols.js";
                       "span",
                       { style: "opacity: 0.5" },
                       ` (pending ${object._schema[ItemsSym].name} `,
-                      ["object", { object: object._refs[i] }],
+                      ["object", { object: object.$jazz.refs[i] }],
                       ")",
                     ],
                   ]

package/src/tools/implementation/invites.ts

@@ -14,7 +14,7 @@ export function createInviteLink<C extends CoValue>(
   baseURL: string,
   valueHint?: string,
 ): string {
-  const coValueCore = value._raw.core;
+  const coValueCore = value.$jazz.raw.core;
   let currentCoValue = coValueCore;
 
   while (currentCoValue.verified.header.ruleset.type === "ownedByGroup") {
@@ -31,7 +31,7 @@ export function createInviteLink<C extends CoValue>(
   const inviteSecret = group.createInvite(role);
 
   return `${baseURL}#/invite/${valueHint ? valueHint + "/" : ""}${
-    value.id
+    value.$jazz.id
   }/${inviteSecret}`;
 }
 

package/src/tools/implementation/schema.ts

@@ -92,24 +92,24 @@ export const coField = {
 };
 
 function optionalRef<C extends CoValueClass>(
-  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
 ): InstanceType<C> | null | undefined {
   return ref(arg, { optional: true });
 }
 
 function ref<C extends CoValueClass>(
-  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
   options?: never,
 ): InstanceType<C> | null;
 function ref<C extends CoValueClass>(
-  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
   options: { optional: true },
 ): InstanceType<C> | null | undefined;
 function ref<
   C extends CoValueClass,
   Options extends { optional?: boolean } | undefined,
 >(
-  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
   options?: Options,
 ): Options extends { optional: true }
   ? InstanceType<C> | null | undefined
@@ -164,17 +164,17 @@ export function instantiateRefEncodedFromRaw<V extends CoValue>(
 export function instantiateRefEncodedWithInit<V extends CoValue>(
   schema: RefEncoded<V>,
   init: any,
-  parentOwner: Account | Group,
+  parentOwner: Group,
 ): V {
   if (!isCoValueClass<V>(schema.ref)) {
     throw Error(
       `Cannot automatically create CoValue from value: ${JSON.stringify(init)}. Use the CoValue schema's create() method instead.`,
     );
   }
-  const node = parentOwner._raw.core.node;
+  const node = parentOwner.$jazz.localNode;
   const rawGroup = node.createGroup();
   const owner = new Group({ fromRaw: rawGroup });
-  owner.addMember(parentOwner.castAs(Group));
+  owner.addMember(parentOwner);
   // @ts-expect-error - create is a static method in all CoValue classes
   return schema.ref.create(init, owner);
 }

package/src/tools/implementation/symbols.ts

@@ -8,3 +8,6 @@ export type ItemsSym = typeof ItemsSym;
 
 export const MembersSym = "$members$";
 export type MembersSym = typeof MembersSym;
+
+export const TypeSym = "$type$";
+export type TypeSym = typeof TypeSym;

package/src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts

@@ -158,13 +158,13 @@ export interface CoreAccountSchema<
 }
 
 export type AccountInstance<Shape extends z.core.$ZodLooseShape> = {
-  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+  readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
 } & Account;
 
 export type AccountInstanceCoValuesNullable<
   Shape extends z.core.$ZodLooseShape,
 > = {
-  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+  readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
     Shape[key]
   >;
 } & Account;

package/src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts

@@ -10,7 +10,7 @@ import {
   coOptionalDefiner,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { CoFeedInit } from "../typeConverters/CoFieldInit.js";
+import { CoFeedSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
@@ -28,7 +28,16 @@ export class CoFeedSchema<T extends AnyZodOrCoValueSchema>
   ) {}
 
   create(
-    init: CoFeedInit<T>,
+    init: CoFeedSchemaInit<T>,
+    options?: { owner: Group } | Group,
+  ): CoFeedInstance<T>;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  create(
+    init: CoFeedSchemaInit<T>,
+    options?: { owner: Account | Group } | Account | Group,
+  ): CoFeedInstance<T>;
+  create(
+    init: CoFeedSchemaInit<T>,
     options?: { owner: Account | Group } | Account | Group,
   ): CoFeedInstance<T> {
     return this.coValueClass.create(init as any, options) as CoFeedInstance<T>;

package/src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts

@@ -11,7 +11,7 @@ import {
 } from "../../../internal.js";
 import { CoValueUniqueness } from "cojson";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { CoListInit } from "../typeConverters/CoFieldInit.js";
+import { CoListSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { AnyZodOrCoValueSchema } from "../zodSchema.js";
@@ -30,12 +30,23 @@ export class CoListSchema<T extends AnyZodOrCoValueSchema>
   ) {}
 
   create(
-    items: CoListInit<T>,
+    items: CoListSchemaInit<T>,
     options?:
-      | {
-          owner: Account | Group;
-          unique?: CoValueUniqueness["uniqueness"];
-        }
+      | { owner: Group; unique?: CoValueUniqueness["uniqueness"] }
+      | Group,
+  ): CoListInstance<T>;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  create(
+    items: CoListSchemaInit<T>,
+    options?:
+      | { owner: Account | Group; unique?: CoValueUniqueness["uniqueness"] }
+      | Account
+      | Group,
+  ): CoListInstance<T>;
+  create(
+    items: CoListSchemaInit<T>,
+    options?:
+      | { owner: Account | Group; unique?: CoValueUniqueness["uniqueness"] }
       | Account
       | Group,
   ): CoListInstance<T> {
@@ -82,7 +93,7 @@ export class CoListSchema<T extends AnyZodOrCoValueSchema>
   upsertUnique<
     const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true,
   >(options: {
-    value: CoListInit<T>;
+    value: CoListSchemaInit<T>;
     unique: CoValueUniqueness["uniqueness"];
     owner: Account | Group;
     resolve?: RefsToResolveStrict<CoListInstanceCoValuesNullable<T>, R>;

package/src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts

@@ -17,7 +17,7 @@ import {
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { removeGetters } from "../../schemaUtils.js";
-import { CoMapSchemaInit } from "../typeConverters/CoFieldInit.js";
+import { CoMapSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { z } from "../zodReExport.js";
@@ -30,15 +30,25 @@ export interface CoMapSchema<
   CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
   Owner extends Account | Group = Account | Group,
 > extends CoreCoMapSchema<Shape, CatchAll> {
-  create: (
+  create(
     init: CoMapSchemaInit<Shape>,
     options?:
       | {
-          owner: Owner;
+          owner?: Group;
+          unique?: CoValueUniqueness["uniqueness"];
+        }
+      | Group,
+  ): CoMapInstanceShape<Shape, CatchAll> & CoMap;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  create(
+    init: CoMapSchemaInit<Shape>,
+    options?:
+      | {
+          owner?: Owner;
           unique?: CoValueUniqueness["uniqueness"];
         }
       | Owner,
-  ) => CoMapInstanceShape<Shape, CatchAll> & CoMap;
+  ): CoMapInstanceShape<Shape, CatchAll> & CoMap;
 
   load<
     const R extends RefsToResolve<
@@ -298,16 +308,16 @@ export type CoMapInstanceShape<
   Shape extends z.core.$ZodLooseShape,
   CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
 > = {
-  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+  readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
 } & (CatchAll extends AnyZodOrCoValueSchema
   ? {
-      [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
+      readonly [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
     }
   : {});
 
 export type CoMapInstanceCoValuesNullable<Shape extends z.core.$ZodLooseShape> =
   {
-    -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+    readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
       Shape[key]
     >;
   };

package/src/tools/implementation/zodSchema/schemaTypes/CoRecordSchema.ts

@@ -12,7 +12,7 @@ import {
   SubscribeListenerOptions,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { CoFieldInit } from "../typeConverters/CoFieldInit.js";
+import { CoFieldSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { z } from "../zodReExport.js";
@@ -24,25 +24,27 @@ type CoRecordInit<
   K extends z.core.$ZodString<string>,
   V extends AnyZodOrCoValueSchema,
 > = {
-  [key in z.output<K>]: CoFieldInit<V>;
+  [key in z.output<K>]: CoFieldSchemaInit<V>;
 };
 
 export interface CoRecordSchema<
   K extends z.core.$ZodString<string>,
   V extends AnyZodOrCoValueSchema,
 > extends CoreCoRecordSchema<K, V> {
-  create: (
+  create(
     init: Simplify<CoRecordInit<K, V>>,
     options?:
-      | {
-          owner: Account | Group;
-          unique?: CoValueUniqueness["uniqueness"];
-        }
+      | { owner: Group; unique?: CoValueUniqueness["uniqueness"] }
+      | Group,
+  ): CoRecordInstanceShape<K, V> & CoMap;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  create(
+    init: Simplify<CoRecordInit<K, V>>,
+    options?:
+      | { owner: Account | Group; unique?: CoValueUniqueness["uniqueness"] }
       | Account
       | Group,
-  ) => {
-    [key in z.output<K>]: InstanceOrPrimitiveOfSchema<V>;
-  } & CoMap;
+  ): CoRecordInstanceShape<K, V> & CoMap;
 
   load<
     const R extends RefsToResolve<
@@ -136,5 +138,12 @@ export type CoRecordInstanceCoValuesNullable<
   K extends z.core.$ZodString<string>,
   V extends AnyZodOrCoValueSchema,
 > = {
-  [key in z.output<K>]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
+  readonly [key in z.output<K>]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
 } & CoMap;
+
+export type CoRecordInstanceShape<
+  K extends z.core.$ZodString<string>,
+  V extends AnyZodOrCoValueSchema,
+> = {
+  readonly [key in z.output<K>]: InstanceOrPrimitiveOfSchema<V>;
+};

package/src/tools/implementation/zodSchema/schemaTypes/FileStreamSchema.ts

@@ -25,15 +25,32 @@ export class FileStreamSchema implements CoreFileStreamSchema {
 
   constructor(private coValueClass: typeof FileStream) {}
 
-  create(options?: { owner?: Account | Group } | Account | Group): FileStream {
+  create(options?: { owner: Group } | Group): FileStream;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  create(options?: { owner: Account | Group } | Account | Group): FileStream;
+  create(options?: { owner: Account | Group } | Account | Group): FileStream {
     return this.coValueClass.create(options);
   }
 
+  createFromBlob(
+    blob: Blob | File,
+    options?:
+      | { owner?: Group; onProgress?: (progress: number) => void }
+      | Group,
+  ): Promise<FileStream>;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  createFromBlob(
+    blob: Blob | File,
+    options?:
+      | { owner?: Account | Group; onProgress?: (progress: number) => void }
+      | Account
+      | Group,
+  ): Promise<FileStream>;
   createFromBlob(
     blob: Blob | File,
     options?:
       | {
-          owner?: Group | Account;
+          owner?: Account | Group;
           onProgress?: (progress: number) => void;
         }
       | Account

package/src/tools/implementation/zodSchema/schemaTypes/PlainTextSchema.ts

@@ -26,6 +26,12 @@ export class PlainTextSchema implements CorePlainTextSchema {
 
   constructor(private coValueClass: typeof CoPlainText) {}
 
+  create(text: string, options?: { owner: Group } | Group): CoPlainText;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  create(
+    text: string,
+    options?: { owner: Account | Group } | Account | Group,
+  ): CoPlainText;
   create(
     text: string,
     options?: { owner: Account | Group } | Account | Group,

package/src/tools/implementation/zodSchema/schemaTypes/RichTextSchema.ts

@@ -25,6 +25,12 @@ export class RichTextSchema implements CoreRichTextSchema {
 
   constructor(private coValueClass: typeof CoRichText) {}
 
+  create(text: string, options?: { owner: Group } | Group): CoRichText;
+  /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
+  create(
+    text: string,
+    options?: { owner: Account | Group } | Account | Group,
+  ): CoRichText;
   create(
     text: string,
     options?: { owner: Account | Group } | Account | Group,