@seedprotocol/sdk 0.7.8 → 0.7.9-next.1177.ga3e08ed

package/dist/dist/ClientManager-GZfXErDX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientManager-GZfXErDX.d.ts","sourceRoot":"","sources":["../ClientManager-GZfXErDX.js"],"names":[],"mappings":"AAoxCA;;;;;KAqDC;AAiCD;;;;;;;;;;;;;;;;;;;;;MAyMC;;IAy7GkB,8BAGd;IACW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAGX;IAMiB,qDAKjB;IAMK,2CAoBL;IACa,qDAUb;IACa;;;OAKb;IACkB,2CAGlB;IACoB,6CAGpB;IAMuB,8DAMvB;IAK8B;;;OAmB9B;IAKY,kDAYZ;IACS,gDAWT;IAKQ,4CAkBR;IACK,sBAAwC;IACtC,wBAAuC;;AAjjKnD;;;GAGG;AACH;;;;EA0BC;AAm2BD,yFAAyF;AACzF,0CAAmC,YAAY,CAAC;AAgrHhD;;;;GAIG;AACH,qEAaC;AArtID,uEAaC;AACD,sDAEC;AAs6ID,mDAEkH;AA/5IlH,kFAQC;AA7VD;;;GAGG;AACH,gEAIC;AAsQD,2CAMC;AA8vID,6DAA6D;AAC7D,wDAGC;AAz1GD;;;;;GAKG;AACH,iEASC;AA+2CD;;;;GAIG;AACH;;;EAMC;AAqCD;;;;;;;;GAQG;AACH,+HAiBC;AA7ID;;;;;GAKG;AACH,2GA4DC;AAqpCD,8DAA8D;AAC9D;IACI,0BAIC;IAFG,aAAsB;CAG7B;AAjyED;;;;;;;;GAQG;AAm3CH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAUG;AAurBH;;;;;;;;GAQG;AA4UH;;;;;;;;;;GAUG;AAwrCH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAhKI;;;;WAIG;;QAOH;;;;WAIG;;;;;;;;;QA+CH;;;;WAIG;;QAQH;;;WAGG;;;;;QAqBH;;;WAGG;;;QA0BH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAlIH;;;;WAIG;;QAOH;;;;WAIG;;;;;;;;;QA+CH;;;;WAIG;;QAQH;;;WAGG;;;;;QAqBH;;;WAGG;;;QA0BH;;;WAGG;;;;;GAqCJ;AA36CH,2DAA2D;AAC3D;;;GAuBC;AAGD;;GAuCC;AAnHD;;;;GAIG;AACH;;;;;;GA2CC;AAoED,+EAA+E;AAC/E,4DAiBC;AA7LD;;;GAGG;AACH;;;GAGG;AACH;;;;UAuBC;AAlJD,yDAAyD;AACzD,wFAaC;AApCD,gEAAgE;AAChE,oEAoBC;AAh5DD;;GAEG;AACH,gEA0BC;AAmQD,iGAEC;AAojBD;;;;;;;GAOG;AACH,kEAiBC;AA7xBD;;;;;GAKG;AACH;;;;;;;;;;;;;;;;;;EAkDC;AAsuBD;;;;;;GAMG;AACH,uEAyIC;AAg6BD,+CAA+C;AAC/C,mGAQC;AA19DD,4DAEC;AA5iBD;;;GAGG;AACH,qDAWC;AAwtHD;;;;;;;;;GASG;AACH,sEAiDC;AA7WD;;;;;;GAMG;AACH;;;;;;;;;;;EAoKC;AAv1FD;;;;;;;;GAQG;AACH;;;;GAgBC;AAwkED,oFAAoF;AACpF,yCA4DC;AAxED;;;GAGG;AACH,uDAKC;AAx/GD;;;;;;;;;;;;;iCAAiD;AAuvJjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA5JI;;;;OAIG;;IAOH;;;;OAIG;;;;;;;;;IA+CH;;;;OAIG;;IAQH;;;OAGG;;;;;IAqBH;;;OAGG;;;IA0BH;;;OAGG;;;;EA4BN;AAxoID;;;GAGG;AACH,wEAIC;AAqpHD;;;;;;GAMG;AACH,iIAMC;AAhoGD;;;;GAIG;AACH,mEAOC;AAomGD,6DAEC;AA50GD;;;GAGG;AACH,yDAWC;AAxID;;;;;GAKG;AACH;;;;KA4CC;AA4pED;;;;;GAKG;AACH;;;;;;GAMG;AACH;;;;;;;;UA0CC;AAwED;;;;;;GAMG;AACH,2EAuEC;AArJD;;;GAGG;AACH,oFAUC"}

package/dist/dist/{Item-CjTEShfk.d.ts → Item-0oDoTPhi.d.ts}

@@ -1,19 +1,24 @@
-declare function getGetPublisherForNewSeeds(): any;
 /**
- * Throws OwnershipError if the item is not owned. Use before write operations
- * (publish, save, destroy).
+ * Metadata rows of a seed numbered per property_name in reader order (`rowNum = 1` is the value to
+ * show): live rows before revoked ones, then newest first. See `compareMetadataRowsLatestFirst`.
  */
-declare function assertItemOwned(item: any): Promise<void>;
+declare function getMetadataLatest({ seedLocalId, seedUid }: {
+    seedLocalId: any;
+    seedUid: any;
+}): any;
 /**
- * Checks if the current user owns the item: its publisher is in the persisted owned addresses,
- * or it's a local unsealed draft (no publisher, no real uid, no attestationRaw). Such a draft
- * was made with no wallet connected and is editable until `claimUnpublishedDrafts`, which
- * connecting a wallet calls, gives it that wallet as publisher.
+ * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
  *
- * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers,
- * not wallets the user controls).
+ * For **published chain JSON** (Seed → latest attested Version → properties),
+ * prefer `getPublishedSeedRecord` from `@seedprotocol/sdk` or
+ * `getSeed` / `queryBySchema` from `@seedprotocol/query`. This function remains
+ * the correct path for local-head / draft-wins property selection used by Item.
  */
-declare function isItemOwned(item: any): Promise<boolean>;
+declare function getItemData({ modelName, seedLocalId, seedUid, }: {
+    modelName: any;
+    seedLocalId: any;
+    seedUid: any;
+}): Promise<any>;
 /**
  * Wait for an entity's state machine to reach 'idle' state
  * @param entity - Entity instance with getService() method
@@ -31,7 +36,8 @@ declare function compareMetadataRowsLatestFirst(a: any, b: any): number;
  */
 declare function getEasSchemaUidForModel(modelName: any): Promise<any>;
 /**
- * Latest version row for the seed (by createdAt) whose uid is a real EAS attestation id.
+ * Latest version row for the seed (by `LATEST_VERSION_ORDER_SQL`) whose uid is a real EAS
+ * attestation id.
  * Skips legacy 'NULL' / ZERO_BYTES32 placeholders, non-bytes32 strings, and revoked versions
  * (`revoked_at` set): after a full unpublish the seed has no published version.
  */
@@ -46,6 +52,11 @@ declare function getLatestPublishedVersionRow(seedLocalId: any): Promise<{
 declare function parseListPropertyValueFromStorage(raw: any): any;
 /** Splits `values` into chunks of at most `size` (one empty list gives no chunks). */
 declare function chunkValues(values: any, size?: number): any[];
+/**
+ * Rows per multi-row INSERT into `table` so the statement binds at most
+ * {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} parameters even with every column set.
+ */
+declare function rowsPerInsert(table: any): number;
 declare class Item {
     /** Prefer local id so list rows (local + uid) resolve the same cache entry as early draft loads. */
     static findItemInstanceCacheEntryByProps(props: any): any;
@@ -312,17 +323,18 @@ declare namespace Item {
     let instanceCache: Map<any, any>;
     let CREATE_METADATA_KEYS: Set<string>;
 }
+declare function getGetAdditionalSyncAddresses(): any;
 /**
- * Rows per multi-row INSERT into `table` so the statement binds at most
- * {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} parameters even with every column set.
+ * True when a version row's attestation was revoked (`versions.revoked_at` set). 0 counts as
+ * "not revoked", like `seeds.revoked_at`.
  */
-declare function rowsPerInsert(table: any): number;
-declare function getGetAdditionalSyncAddresses(): any;
+declare function isVersionRevoked(revokedAt: any): boolean;
 /**
- * Runs `query` once per chunk of `values` (see {@link chunkValues}), one after another, and
- * concatenates the rows. Use it for `inArray(column, values)` reads whose list can be large.
+ * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
+ * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
+ * events and XState warns about every one of them.
  */
-declare function selectInBatches(values: any, query: any, size?: number): Promise<any[]>;
+declare function isActorStopped(actor: any): boolean;
 /**
  * Canonical "latest metadata row first" ordering, the one readers use to pick a property's value
  * from its rows across versions:
@@ -339,24 +351,13 @@ declare function selectInBatches(values: any, query: any, size?: number): Promis
  * out; keep those in sync.
  */
 declare const METADATA_LATEST_FIRST_ORDER_SQL: "(revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC";
-/**
- * True when a version row's attestation was revoked (`versions.revoked_at` set). 0 counts as
- * "not revoked", like `seeds.revoked_at`.
- */
-declare function isVersionRevoked(revokedAt: any): boolean;
-/** How long a deferred op waits before the drainer tries it again. */
-declare const OUTBOX_DEFER_MS: 50;
-/**
- * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
- * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
- * events and XState warns about every one of them.
- */
-declare function isActorStopped(actor: any): boolean;
 /**
  * Default readyTimeout for create/find/all with waitForReady. Loads that touch OPFS and the DB can take
  * several seconds on slow devices and CI runners; a load that is really stuck still errors.
  */
 declare const DEFAULT_READY_TIMEOUT_MS: 15000;
+/** How long a deferred op waits before the drainer tries it again. */
+declare const OUTBOX_DEFER_MS: 50;
 /**
  * Creates a reactive Proxy that intercepts property access and assignment
  * to read from and write to an actor service's context.
@@ -407,6 +408,8 @@ declare function forceRemoveFromCaches(instance: any, config: any): void;
  * Event names must match what the entity machines expect.
  */
 declare function runDestroyLifecycle(instance: any, config: any): Promise<void>;
+/** {@link LATEST_VERSION_ORDER_SQL} for a Drizzle `orderBy`. */
+declare function latestVersionOrder(): import("drizzle-orm").SQL<unknown>;
 /**
  * A metadata row holds published content when it has a valid EAS attestation uid, or when sync
  * derived it from one (ItemStorage rows from a storage_transaction_id attestation: no uid of their
@@ -430,6 +433,7 @@ declare function createNewItem({ modelName, modelFileId, ...propertyData }: {
     seedLocalId: string;
     versionLocalId: any;
 }>;
+declare function getGetPublisherForNewSeeds(): any;
 /**
  * Appends one op and waits until it settles: its applier's result once applied, or `superseded`
  * when a newer op of its property replaced it. Rejects with OutboxOpFailedError when it fails.
@@ -441,21 +445,13 @@ declare function appendOutboxOpAndWait(input: any): Promise<{
     superseded: boolean;
     result: any;
 }>;
-/**
- * Metadata rows of a seed numbered per property_name in reader order (`rowNum = 1` is the value to
- * show): live rows before revoked ones, then newest first. See `compareMetadataRowsLatestFirst`.
- */
-declare function getMetadataLatest({ seedLocalId, seedUid }: {
-    seedLocalId: any;
-    seedUid: any;
-}): any;
 declare function getPublishExecutor(): any;
 declare function getRevokeExecutor(): any;
 /** @deprecated See UploadExecutor. */
 declare function getUploadExecutor(): any;
 /**
- * Per-seed version aggregates plus the latest version row by (created_at DESC, local_id DESC) via
- * max(created_at) then max(local_id) tie-break.
+ * Per-seed version aggregates plus the latest version row: the first live version by
+ * `LATEST_VERSION_ORDER_SQL`.
  *
  * Revoked versions (`revoked_at` set) are never the latest version and don't count toward
  * `lastVersionPublishedAt`. `versionsCount` and `lastLocalUpdateAt` still cover every version row,
@@ -541,7 +537,7 @@ declare const propertyMachine: import("xstate").StateMachine<{}, import("xstate"
 }, never, {
     type: "propertyMachineIsIdle";
     params: import("xstate").NonReducibleUnknown;
-}, never, "error" | "idle" | "initializing" | "loading" | "waitingForDb" | "hydratingFromDb" | "resolvingRelatedValue" | {
+}, never, "error" | "idle" | "loading" | "waitingForDb" | "hydratingFromDb" | "initializing" | "resolvingRelatedValue" | {
     saving: "analyzingInput" | "doneSaving" | "savingImage" | "savingFile" | "savingHtml" | "savingItemStorage";
 }, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
     id: "itemProperty";
@@ -612,8 +608,6 @@ declare function clearDestroySubscriptions(instance: any, config: any): void;
  */
 declare function unloadEntity(instance: any, config: any): void;
 declare var ClientManagerEvents: any;
-/** Resolve publisher from seed row: `publisher` column, else `attestationRaw.attester`. */
-declare function resolvePublisherFromSeedRow(row: any): any;
 /**
  * The publisher a seed's version and property rows take: the seed's own (its `publisher`, else the
  * attester of its stored attestation). Undefined for a draft that belongs to no wallet yet; those
@@ -649,6 +643,8 @@ declare function updateItemPropertyValue({ localId: localIdParam, propertyName,
     uid: any;
     schemaUid: any;
 } | undefined>;
+/** Resolve publisher from seed row: `publisher` column, else `attestationRaw.attester`. */
+declare function resolvePublisherFromSeedRow(row: any): any;
 declare var getPropertyData$1: Readonly<{
     __proto__: null;
     getPropertyData: ({ propertyName, seedLocalId, seedUid, modelName, }: {
@@ -667,8 +663,8 @@ declare var Item$1: Readonly<{
  * OutboxOpFailedError when it, or the op that superseded it, failed.
  */
 declare function waitForOutboxOp(opId: any): Promise<any>;
-/** Appends one op; see appendOutboxOps. */
-declare function appendOutboxOp(input: any): Promise<any>;
+/** Appends one op and tells the leader to drain. Returns the op id. */
+declare function appendOutboxOp(input: any): Promise<string>;
 /** Attempts before a retryable error fails the op. */
 declare const OUTBOX_MAX_ATTEMPTS: 8;
 /** Applied and superseded ops are kept this long, then pruned. */
@@ -698,22 +694,11 @@ declare class OutboxOpFailedError extends Error {
 declare class OutboxOpRejectedError extends Error {
     constructor(message: any, options: any);
 }
-/** A failure worth retrying (a file the browser had locked, say). Other errors fail the op at once. */
-declare class OutboxOpRetryableError extends Error {
-    constructor(message: any, options: any);
-}
-/**
- * Appends one op, or several that apply together (they share a new group id unless they carry
- * one), and tells the leader to drain. Returns the op ids in order.
- */
-declare function appendOutboxOps(inputs: any): Promise<any>;
 /**
  * Applies every pending op that is due, in order. Exported for tests and for code that must see
  * the outbox applied before it continues; normally the leader drains on its own.
  */
 declare function drainOutbox(): Promise<void>;
-/** What an applied op's applier returned, decoded. */
-declare function outboxOpResult(op: any): any;
 /**
  * The value an item property will have once its pending `set` ops apply, in its stored string form.
  * Undefined when its newest pending value op is not a `set`, or it has none.
@@ -721,6 +706,8 @@ declare function outboxOpResult(op: any): any;
 declare function getPendingSetValue(seedLocalId: any, propertyName: any): Promise<any>;
 /** An op's stored value, decoded. */
 declare function outboxOpValue(op: any): any;
+/** What an applied op's applier returned, decoded. */
+declare function outboxOpResult(op: any): any;
 /**
  * Deletes settled ops older than their retention: applied and superseded ops after
  * OUTBOX_PRUNE_AFTER_MS, failed ones after OUTBOX_PRUNE_FAILED_AFTER_MS. An applied op with an
@@ -728,33 +715,6 @@ declare function outboxOpValue(op: any): any;
  * leader runs it after a drain, at most hourly. Returns how many ops it deleted.
  */
 declare function pruneOutbox(now?: number): Promise<any>;
-/** Registers the applier for one op kind; returns a function that removes it. */
-declare function registerOutboxApplier(kind: any, applier: any): () => void;
-/**
- * Starts draining in this tab once it is the leader, resuming ops left pending (a reload, a closed
- * leader tab), and listens for other tabs' nudges and settled ops. Safe to call more than once.
- */
-declare function startOutbox(): void;
-/** Runs `write` once per chunk of `values`, one after another (deletes / updates with an `IN` list). */
-declare function writeInBatches(values: any, write: any, size?: number): Promise<void>;
-/**
- * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
- *
- * For **published chain JSON** (Seed → latest attested Version → properties),
- * prefer `getPublishedSeedRecord` from `@seedprotocol/sdk` or
- * `getSeed` / `queryBySchema` from `@seedprotocol/query`. This function remains
- * the correct path for local-head / draft-wins property selection used by Item.
- */
-declare function getItemData({ modelName, seedLocalId, seedUid, }: {
-    modelName: any;
-    seedLocalId: any;
-    seedUid: any;
-}): Promise<any>;
-/**
- * Resolves once every op pending when it was called has settled (applied, superseded or failed),
- * so a reader of `metadata` sees every edit made before. Publish waits on this before it reads.
- */
-declare function waitForPendingOutboxOps(): Promise<void>;
 declare class ItemProperty {
     static create(props: any, options: any): any;
     /**
@@ -859,7 +819,7 @@ declare class ItemProperty {
     }, never, {
         type: "propertyMachineIsIdle";
         params: import("xstate").NonReducibleUnknown;
-    }, never, "error" | "idle" | "initializing" | "loading" | "waitingForDb" | "hydratingFromDb" | "resolvingRelatedValue" | {
+    }, never, "error" | "idle" | "loading" | "waitingForDb" | "hydratingFromDb" | "initializing" | "resolvingRelatedValue" | {
         saving: "analyzingInput" | "doneSaving" | "savingImage" | "savingFile" | "savingHtml" | "savingItemStorage";
     }, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
         id: "itemProperty";
@@ -941,7 +901,7 @@ declare class ItemProperty {
     }, never, {
         type: "propertyMachineIsIdle";
         params: import("xstate").NonReducibleUnknown;
-    }, never, "error" | "idle" | "initializing" | "loading" | "waitingForDb" | "hydratingFromDb" | "resolvingRelatedValue" | {
+    }, never, "error" | "idle" | "loading" | "waitingForDb" | "hydratingFromDb" | "initializing" | "resolvingRelatedValue" | {
         saving: "analyzingInput" | "doneSaving" | "savingImage" | "savingFile" | "savingHtml" | "savingItemStorage";
     }, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
         id: "itemProperty";
@@ -967,7 +927,7 @@ declare class ItemProperty {
     }, import("xstate").MetaObject>>;
     _getSnapshot(): import("xstate").MachineSnapshot<{}, import("xstate").AnyEventObject, {
         [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-    }, "error" | "idle" | "initializing" | "loading" | "waitingForDb" | "hydratingFromDb" | "resolvingRelatedValue" | {
+    }, "error" | "idle" | "loading" | "waitingForDb" | "hydratingFromDb" | "initializing" | "resolvingRelatedValue" | {
         saving: "analyzingInput" | "doneSaving" | "savingImage" | "savingFile" | "savingHtml" | "savingItemStorage";
     }, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
         id: "itemProperty";
@@ -1006,7 +966,7 @@ declare class ItemProperty {
     get refResolvedValue(): any;
     get localStoragePath(): string | undefined;
     get versionLocalId(): any;
-    get status(): "error" | "idle" | "initializing" | "loading" | "waitingForDb" | "hydratingFromDb" | "resolvingRelatedValue" | {
+    get status(): "error" | "idle" | "loading" | "waitingForDb" | "hydratingFromDb" | "initializing" | "resolvingRelatedValue" | {
         saving: "analyzingInput" | "doneSaving" | "savingImage" | "savingFile" | "savingHtml" | "savingItemStorage";
     };
     /** Validation errors from last failed save (enum, pattern, minLength, maxLength). Cleared when the next save starts. */
@@ -1065,6 +1025,13 @@ declare namespace ItemProperty {
     let instanceCache_1: Map<any, any>;
     export { instanceCache_1 as instanceCache };
 }
+/** Registers the applier for one op kind; returns a function that removes it. */
+declare function registerOutboxApplier(kind: any, applier: any): () => void;
+/**
+ * Starts draining in this tab once it is the leader, resuming ops left pending (a reload, a closed
+ * leader tab), and listens for other tabs' nudges and settled ops. Safe to call more than once.
+ */
+declare function startOutbox(): void;
 /** Thrown by ItemProperty.save() when the value failed validation (enum, pattern, minLength, maxLength). */
 declare class ItemPropertySaveValidationError extends Error {
     constructor(message: any, validationErrors: any);
@@ -1077,6 +1044,33 @@ declare class ItemPropertySaveValidationError extends Error {
 declare class OwnershipError extends Error {
     constructor(message?: string);
 }
+/**
+ * Throws OwnershipError if the item is not owned. Use before write operations
+ * (publish, save, destroy).
+ */
+declare function assertItemOwned(item: any): Promise<void>;
+/**
+ * Resolves once every op pending when it was called has settled (applied, superseded or failed),
+ * so a reader of `metadata` sees every edit made before. Publish waits on this before it reads.
+ */
+declare function waitForPendingOutboxOps(): Promise<void>;
+/**
+ * Checks if the current user owns the item: its publisher is in the persisted owned addresses,
+ * or it's a local unsealed draft (no publisher, no real uid, no attestationRaw). Such a draft
+ * was made with no wallet connected and is editable until `claimUnpublishedDrafts`, which
+ * connecting a wallet calls, gives it that wallet as publisher.
+ *
+ * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers,
+ * not wallets the user controls).
+ */
+declare function isItemOwned(item: any): Promise<boolean>;
+/** Runs `write` once per chunk of `values`, one after another (deletes / updates with an `IN` list). */
+declare function writeInBatches(values: any, write: any, size?: number): Promise<void>;
+/**
+ * Runs `query` once per chunk of `values` (see {@link chunkValues}), one after another, and
+ * concatenates the rows. Use it for `inArray(column, values)` reads whose list can be large.
+ */
+declare function selectInBatches(values: any, query: any, size?: number): Promise<any[]>;
 import { BehaviorSubject } from 'rxjs';
-export { getGetPublisherForNewSeeds as $, assertItemOwned as A, isItemOwned as B, waitForEntityIdle as C, compareMetadataRowsLatestFirst as D, getEasSchemaUidForModel as E, getLatestPublishedVersionRow as F, parseListPropertyValueFromStorage as G, chunkValues as H, Item as I, rowsPerInsert as J, getGetAdditionalSyncAddresses as K, selectInBatches as L, METADATA_LATEST_FIRST_ORDER_SQL as M, isVersionRevoked as N, OUTBOX_DEFER_MS as O, isActorStopped as P, DEFAULT_READY_TIMEOUT_MS as Q, createReactiveProxy as R, sameEntity as S, findEntity as T, forceRemoveFromCaches as U, runDestroyLifecycle as V, isPublishedMetadataRow as W, ClientManagerState as X, MachineIds as Y, PUBLISH_NOT_CONFIGURED_MESSAGE as Z, createNewItem as _, appendOutboxOpAndWait as a, getMetadataLatest as a0, getPublishExecutor as a1, getRevokeExecutor as a2, getUploadExecutor as a3, getVersionData$1 as a4, isLocalUnsealedDraft as a5, isSeedRowOwned as a6, localUnsealedDraftSql as a7, ownedPublisherSql as a8, ownedSeedsSql as a9, pickLatestMetadataRowPerProperty as aa, placeholderUidSql as ab, propertyMachine as ac, publisherInAddressListSql as ad, publisherIsInOwnedSet as ae, setAdditionalSyncAddresses as af, setGetPublisherForNewSeeds as ag, setPublishExecutor as ah, setRevokeExecutor as ai, setUploadExecutor as aj, ActorKeyedState as ak, clearDestroySubscriptions as al, unloadEntity as am, ClientManagerEvents as an, resolvePublisherFromSeedRow as ao, getSeedPublisher as ap, propertyNameVariants as aq, createSeed as ar, createMetadata as as, updateItemPropertyValue as at, getPropertyData$1 as au, Item$1 as av, waitForOutboxOp as b, appendOutboxOp as c, OUTBOX_MAX_ATTEMPTS as d, OUTBOX_PRUNE_AFTER_MS as e, OUTBOX_PRUNE_FAILED_AFTER_MS as f, getOutboxOps as g, OUTBOX_RETRY_DELAYS_MS as h, OutboxOpDeferredError as i, OutboxOpFailedError as j, OutboxOpRejectedError as k, OutboxOpRetryableError as l, appendOutboxOps as m, drainOutbox as n, outboxOpResult as o, getPendingSetValue as p, outboxOpValue as q, pruneOutbox as r, registerOutboxApplier as s, startOutbox as t, writeInBatches as u, getItemData as v, waitForPendingOutboxOps as w, ItemProperty as x, ItemPropertySaveValidationError as y, OwnershipError as z };
-//# sourceMappingURL=Item-CjTEShfk.d.ts.map
+export { getMetadataLatest as $, getItemData as A, waitForEntityIdle as B, compareMetadataRowsLatestFirst as C, getEasSchemaUidForModel as D, getLatestPublishedVersionRow as E, parseListPropertyValueFromStorage as F, chunkValues as G, rowsPerInsert as H, Item as I, getGetAdditionalSyncAddresses as J, isVersionRevoked as K, isActorStopped as L, METADATA_LATEST_FIRST_ORDER_SQL as M, DEFAULT_READY_TIMEOUT_MS as N, OUTBOX_DEFER_MS as O, createReactiveProxy as P, sameEntity as Q, findEntity as R, forceRemoveFromCaches as S, runDestroyLifecycle as T, latestVersionOrder as U, isPublishedMetadataRow as V, ClientManagerState as W, MachineIds as X, PUBLISH_NOT_CONFIGURED_MESSAGE as Y, createNewItem as Z, getGetPublisherForNewSeeds as _, appendOutboxOpAndWait as a, getPublishExecutor as a0, getRevokeExecutor as a1, getUploadExecutor as a2, getVersionData$1 as a3, isLocalUnsealedDraft as a4, isSeedRowOwned as a5, localUnsealedDraftSql as a6, ownedPublisherSql as a7, ownedSeedsSql as a8, pickLatestMetadataRowPerProperty as a9, placeholderUidSql as aa, propertyMachine as ab, publisherInAddressListSql as ac, publisherIsInOwnedSet as ad, setAdditionalSyncAddresses as ae, setGetPublisherForNewSeeds as af, setPublishExecutor as ag, setRevokeExecutor as ah, setUploadExecutor as ai, ActorKeyedState as aj, clearDestroySubscriptions as ak, unloadEntity as al, ClientManagerEvents as am, getSeedPublisher as an, propertyNameVariants as ao, createSeed as ap, createMetadata as aq, updateItemPropertyValue as ar, resolvePublisherFromSeedRow as as, getPropertyData$1 as at, Item$1 as au, waitForOutboxOp as b, appendOutboxOp as c, OUTBOX_MAX_ATTEMPTS as d, OUTBOX_PRUNE_AFTER_MS as e, OUTBOX_PRUNE_FAILED_AFTER_MS as f, getOutboxOps as g, OUTBOX_RETRY_DELAYS_MS as h, OutboxOpDeferredError as i, OutboxOpFailedError as j, OutboxOpRejectedError as k, drainOutbox as l, getPendingSetValue as m, outboxOpValue as n, outboxOpResult as o, pruneOutbox as p, ItemProperty as q, registerOutboxApplier as r, startOutbox as s, ItemPropertySaveValidationError as t, OwnershipError as u, assertItemOwned as v, waitForPendingOutboxOps as w, isItemOwned as x, writeInBatches as y, selectInBatches as z };
+//# sourceMappingURL=Item-0oDoTPhi.d.ts.map

package/dist/dist/Item-0oDoTPhi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Item-0oDoTPhi.d.ts","sourceRoot":"","sources":["../Item-0oDoTPhi.js"],"names":[],"mappings":"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"}

package/dist/dist/{ModelProperty-C3749Wjq.d.ts → ModelProperty-i5flwzQG.d.ts}

@@ -312,4 +312,4 @@ export namespace ModelProperty {
     let idIndex: Map<any, any>;
     let pendingWrites: Map<any, any>;
 }
-//# sourceMappingURL=ModelProperty-C3749Wjq.d.ts.map
+//# sourceMappingURL=ModelProperty-i5flwzQG.d.ts.map

package/dist/dist/{ModelProperty-C3749Wjq.d.ts.map → ModelProperty-i5flwzQG.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"ModelProperty-C3749Wjq.d.ts","sourceRoot":"","sources":["../ModelProperty-C3749Wjq.js"],"names":[],"mappings":"AA21BA;IAyZI,gDA+RC;IACD,+EAA+E;IAC/E,qEAUC;IACD,8FAA8F;IAC9F,+DAmBC;IACD;;;;OAIG;IACH,0CAMC;IACD;;OAEG;IACH,yCAmBC;IACD;;;OAGG;IACH,mEAyFC;IACD;;;;;;OAMG;IACH,0DAyEC;IACD;;;;;OAKG;IACH;;;;qBAWC;IACD;;;OAGG;IACH,2DAqBC;IACD;;OAEG;IACH,kEAOC;IACD;;;;OAIG;IACH,8EAQC;IACD;;OAEG;IACH,qEAeC;IACD;;OAEG;IACH,kDAIC;IACD;;;OAGG;IACH,mDAEC;IAyGD;;;;OAIG;IACH,8DAwBC;IAvpCD,2BAqBC;IApBG,2GAA2G;IAC3G,uBAA4C;IAY5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAMN;;;OAGG;IACH,iCAIC;IACD;;;;;OAKG;IACH,+CA+GC;IACD;;;;;OAKG;IACH,wEAgCC;IACD;;;;OAIG;IACH,mEAuBC;IACD,6EAA6E;IAC7E;;;MAOC;IACD;;;OAGG;IACH;;;;;;;mBA8EC;IACD;;;OAGG;IACH,6CAiDC;IACD;;;OAGG;IACH,kEA8BC;IACD;;;OAGG;IACH,qCAKC;IA2nBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,+BAMC;IACD,iBAEC;IACD,oBAcC;IACD,4BAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD,aAaC;IACD;;;;;OAKG;IACH,wBAOC;IA+BD;;;;OAIG;IACH,eAmBC;IACD;;OAEG;IACH,yBAmEC;CACJ"}
+{"version":3,"file":"ModelProperty-i5flwzQG.d.ts","sourceRoot":"","sources":["../ModelProperty-i5flwzQG.js"],"names":[],"mappings":"AA41BA;IAyZI,gDA+RC;IACD,+EAA+E;IAC/E,qEAUC;IACD,8FAA8F;IAC9F,+DAmBC;IACD;;;;OAIG;IACH,0CAMC;IACD;;OAEG;IACH,yCAmBC;IACD;;;OAGG;IACH,mEAyFC;IACD;;;;;;OAMG;IACH,0DAyEC;IACD;;;;;OAKG;IACH;;;;qBAWC;IACD;;;OAGG;IACH,2DAqBC;IACD;;OAEG;IACH,kEAOC;IACD;;;;OAIG;IACH,8EAQC;IACD;;OAEG;IACH,qEAeC;IACD;;OAEG;IACH,kDAIC;IACD;;;OAGG;IACH,mDAEC;IAyGD;;;;OAIG;IACH,8DAwBC;IAvpCD,2BAqBC;IApBG,2GAA2G;IAC3G,uBAA4C;IAY5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAMN;;;OAGG;IACH,iCAIC;IACD;;;;;OAKG;IACH,+CA+GC;IACD;;;;;OAKG;IACH,wEAgCC;IACD;;;;OAIG;IACH,mEAuBC;IACD,6EAA6E;IAC7E;;;MAOC;IACD;;;OAGG;IACH;;;;;;;mBA8EC;IACD;;;OAGG;IACH,6CAiDC;IACD;;;OAGG;IACH,kEA8BC;IACD;;;OAGG;IACH,qCAKC;IA2nBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,+BAMC;IACD,iBAEC;IACD,oBAcC;IACD,4BAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD,aAaC;IACD;;;;;OAKG;IACH,wBAOC;IA+BD;;;;OAIG;IACH,eAmBC;IACD;;OAEG;IACH,yBAmEC;CACJ"}

package/dist/dist/{Schema-CX9CTtho.d.ts → Schema-PFZwG9Nl.d.ts}

@@ -61,54 +61,8 @@ declare class Schema {
     static evict(schemaName: any): void;
     constructor(schemaName: any);
     _service: import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-        }, {
-            src: "validateEntity";
-            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        } | {
-            src: "writeToDatabase";
-            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-            id: "writeProcess";
-            states: {
-                readonly idle: {};
-                readonly validating: {};
-                readonly writing: {};
-                readonly success: {};
-                readonly error: {};
-            };
-        }, import("xstate").MetaObject>> | undefined;
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
     }, {
-        src: "writeProcessMachine";
-        logic: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-        }, {
-            src: "validateEntity";
-            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        } | {
-            src: "writeToDatabase";
-            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-            id: "writeProcess";
-            states: {
-                readonly idle: {};
-                readonly validating: {};
-                readonly writing: {};
-                readonly success: {};
-                readonly error: {};
-            };
-        }, import("xstate").MetaObject>;
-        id: string | undefined;
-    } | {
-        src: "loadOrCreateSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
         src: "validateSchema";
         logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
         id: string | undefined;
@@ -182,54 +136,8 @@ declare class Schema {
         };
     }, import("xstate").MetaObject>>;
     getService(): import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-        }, {
-            src: "validateEntity";
-            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        } | {
-            src: "writeToDatabase";
-            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-            id: "writeProcess";
-            states: {
-                readonly idle: {};
-                readonly validating: {};
-                readonly writing: {};
-                readonly success: {};
-                readonly error: {};
-            };
-        }, import("xstate").MetaObject>> | undefined;
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
     }, {
-        src: "writeProcessMachine";
-        logic: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-        }, {
-            src: "validateEntity";
-            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        } | {
-            src: "writeToDatabase";
-            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-            id: "writeProcess";
-            states: {
-                readonly idle: {};
-                readonly validating: {};
-                readonly writing: {};
-                readonly success: {};
-                readonly error: {};
-            };
-        }, import("xstate").MetaObject>;
-        id: string | undefined;
-    } | {
-        src: "loadOrCreateSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
         src: "validateSchema";
         logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
         id: string | undefined;
@@ -303,26 +211,7 @@ declare class Schema {
         };
     }, import("xstate").MetaObject>>;
     _getSnapshot(): import("xstate").MachineSnapshot<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-        }, {
-            src: "validateEntity";
-            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        } | {
-            src: "writeToDatabase";
-            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-            id: string | undefined;
-        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-            id: "writeProcess";
-            states: {
-                readonly idle: {};
-                readonly validating: {};
-                readonly writing: {};
-                readonly success: {};
-                readonly error: {};
-            };
-        }, import("xstate").MetaObject>> | undefined;
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
     }, "error" | "idle" | "validating" | {
         loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
     }, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
@@ -438,30 +327,11 @@ declare namespace Schema {
     let pendingSchemaByName: Map<any, any>;
     let savingSchemas: Set<any>;
 }
-/**
- * Delete a property from a model in a schema
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model
- * @param propertyName - The name of the property to delete
- * @param options - Optional deletion options
- * @returns The file path of the new schema version
- * @throws Error if schema, model, or property not found
- */
-declare function deletePropertyFromModel(schemaName: any, modelName: any, propertyName: any, _options?: {}): Promise<any>;
 declare var Schema$1: Readonly<{
     __proto__: null;
     Schema: typeof Schema;
     schemaInstanceState: ActorKeyedState;
 }>;
-/**
- * Delete a model from a schema
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model to delete
- * @param options - Optional deletion options
- * @returns The file path of the new schema version
- * @throws Error if schema or model not found
- */
-declare function deleteModelFromSchema(schemaName: any, modelName: any, options?: {}): Promise<any>;
 /**
  * Rename a property in a model
  * This is a convenience function that updates the property name
@@ -474,54 +344,8 @@ declare function deleteModelFromSchema(schemaName: any, modelName: any, options?
  */
 declare function renameModelProperty(schemaName: any, modelName: any, oldPropertyName: any, newPropertyName: any): Promise<any>;
 declare const schemaMachine: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-    }, {
-        src: "validateEntity";
-        logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writeToDatabase";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-        id: "writeProcess";
-        states: {
-            readonly idle: {};
-            readonly validating: {};
-            readonly writing: {};
-            readonly success: {};
-            readonly error: {};
-        };
-    }, import("xstate").MetaObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
 }, {
-    src: "writeProcessMachine";
-    logic: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-    }, {
-        src: "validateEntity";
-        logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writeToDatabase";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-        id: "writeProcess";
-        states: {
-            readonly idle: {};
-            readonly validating: {};
-            readonly writing: {};
-            readonly success: {};
-            readonly error: {};
-        };
-    }, import("xstate").MetaObject>;
-    id: string | undefined;
-} | {
-    src: "loadOrCreateSchema";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
     src: "validateSchema";
     logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
     id: string | undefined;
@@ -603,6 +427,6 @@ declare const schemaMachine: import("xstate").StateMachine<{}, import("xstate").
  * @throws Error if schema not found or updates are invalid
  */
 declare function updateModelProperties(schemaName: any, propertyUpdates: any, modelUpdates: any): Promise<any>;
-import { ak as ActorKeyedState } from './Item-CjTEShfk.js';
-export { Schema as S, deletePropertyFromModel as a, Schema$1 as b, deleteModelFromSchema as d, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-CX9CTtho.d.ts.map
+import { aj as ActorKeyedState } from './Item-0oDoTPhi.js';
+export { Schema as S, Schema$1 as a, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
+//# sourceMappingURL=Schema-PFZwG9Nl.d.ts.map

package/dist/dist/Schema-PFZwG9Nl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema-PFZwG9Nl.d.ts","sourceRoot":"","sources":["../Schema-PFZwG9Nl.js"],"names":[],"mappings":"AAkhFA;IAiCI,kDAoPC;IACD;;;;OAIG;IACH,iEAaC;IACD;;;OAGG;IACH,uCAMC;IACD;;;OAGG;IACH,0CAGC;IACD;;;;OAIG;IACH,0BAwBC;IACD;;;;;OAKG;IACH,iEAgCC;IACD;;;;;OAKG;IACH;;;;qBAgBC;IACD;;;;;;;;;;OAUG;IACH,yCA+IC;IA01BD;;;;;OAKG;IACH,oCAkCC;IAn7CD,6BA+BC;IA3BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IA4iBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,sBAeC;IACD,wBAEC;IACD,cAEC;IACD;;;;OAIG;IACH,oBAmCC;IACD;;MAEC;IACD,oBAcC;IACD,4BAEC;IACD;;;OAGG;IACH,yBAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD;;;;OAIG;IACH,yCAoEC;IACD;;;;;;OAMG;IACH,+BAqLC;IACD;;;OAGG;IACH;;;;;;;;;;;;;;OAyCC;IACD;;;OAGG;IACH,uBAwBC;IACD;;;;;OAKG;IACH,0DAqXC;IA0CD,eAwCC;IACD;;;OAGG;IACH,yBAgCC;IACD,mFAqEC;IACD;;;OAGG;IACH,oCAgKC;CACJ;;;;;;;AAUD;;;;GAIG;AA54DH;;;;;;;;;GASG;AACH,gIAsGC;AAniCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAwgBG;AA2LH;;;;;;;GAOG;AACH,+GA6HC;sCA9wE2Q,oBAAoB"}