@arkiv-network/sdk 0.8.1-dev.1 → 0.9.0-next.2

package/dist/index.cjs

@@ -1,13 +1,12 @@
 const require_chains = require('./chains-Etgm64UM.cjs');
-const require_attr = require('./attr-BXTkpnoc.cjs');
-const require_query = require('./query-9oojUdM7.cjs');
+const require_query = require('./query-D0KtuFh2.cjs');
+const require_schema = require('./schema-B9AyXcgU.cjs');
 const require_errors = require('./errors-DhV00966.cjs');
-const require_flags = require('./flags-DCD26uhe.cjs');
-const require_entity = require('./entity-B0t6sN7F.cjs');
-const require_expiry = require('./expiry-CG9GhVXv.cjs');
-const require_entity$1 = require('./entity-DJ0Gml9c.cjs');
+const require_entity = require('./entity-BM1unrQf.cjs');
+const require_params = require('./params-BuIrJA9a.cjs');
+const require_entity$1 = require('./entity-BgaFJSaV.cjs');
+const require_expirationTime = require('./expirationTime-CkIGNAg8.cjs');
 require('./types-CKPddlfS.cjs');
-const require_payload = require('./payload-DqFweqiO.cjs');
 let viem = require("viem");
 let viem_actions = require("viem/actions");
 
@@ -28,35 +27,15 @@ async function getBlockTiming(client) {
 
 //#endregion
 //#region src/actions/public/getEntity.ts
-/**
-* Reads one entity by key, with every field selected.
-*
-* Returns a {@link FullEntity} rather than an {@link Entity}: the selection is fixed at `"*"`, so
-* every field is populated and none of them needs a `?` at the call site. The bare `Entity` type
-* has every field optional because a `select()` result carries only what it asked for.
-*
-* @throws {InvalidValueError} If the key is not 32 bytes.
-* @throws {NoEntityFoundError} If no live entity has that key — it never existed, or it was
-* deleted or has expired.
-*/
-async function getEntity(client, entityKey) {
-	const { entities } = await require_query.runQuery(client, {
-		query: require_query.eq("$key", require_attr.key(entityKey)).toString(),
-		select: require_query.toRpcSelect("*"),
-		limit: 1
-	});
-	const entity = entities[0];
-	if (entity === void 0) throw new require_query.NoEntityFoundError(entityKey);
-	return entity;
-}
-
-//#endregion
-//#region src/actions/public/getEntityCount.ts
-async function getEntityCount(client) {
-	return await client.request({
-		method: "arkiv_getEntityCount",
-		params: []
+async function getEntity(client, entityKey, schema) {
+	if (schema !== void 0 && !require_schema.isSchema(schema)) throw new require_schema.SchemaDefinitionError("getEntity() takes a schema built with defineSchema(...)");
+	const projection = require_query.projectSelection("*", schema);
+	const rpcEntity = await client.request({
+		method: "arkiv_getEntity",
+		params: [require_schema.key(entityKey).value]
 	});
+	if (rpcEntity === null) throw new require_query.NoEntityFoundError(entityKey);
+	return require_query.toRow(require_query.entityFromRpcResult(rpcEntity), projection);
 }
 
 //#endregion
@@ -85,17 +64,17 @@ const ATTRIBUTE_TUPLE = "(bytes32 name, uint8 typeId, bytes value)[]";
 * selects — a tagged union, so a new operation is additive rather than a change to `execute`.
 */
 const PAYLOAD_PARAMS = {
-	[require_expiry.OperationType.Create]: (0, viem.parseAbiParameters)(`(uint128 salt, uint64 expiresAt, uint64 minLifetime, uint8 creationFlags, ${ATTRIBUTE_TUPLE} attributes)`),
-	[require_expiry.OperationType.Patch]: (0, viem.parseAbiParameters)(`(bytes32 entityKey, ${ATTRIBUTE_TUPLE} mutations)`),
-	[require_expiry.OperationType.ExtendExpiry]: (0, viem.parseAbiParameters)("(bytes32 entityKey, uint64 expiresAt, uint64 minLifetime)"),
-	[require_expiry.OperationType.TransferOwnership]: (0, viem.parseAbiParameters)("(bytes32 entityKey, address newOwner)"),
-	[require_expiry.OperationType.Delete]: (0, viem.parseAbiParameters)("(bytes32 entityKey)")
+	[require_params.OperationType.Create]: (0, viem.parseAbiParameters)(`(uint128 salt, uint64 expiresAt, uint64 minLifetime, uint8 creationFlags, ${ATTRIBUTE_TUPLE} attributes)`),
+	[require_params.OperationType.Patch]: (0, viem.parseAbiParameters)(`(bytes32 entityKey, ${ATTRIBUTE_TUPLE} mutations)`),
+	[require_params.OperationType.ExtendExpiry]: (0, viem.parseAbiParameters)("(bytes32 entityKey, uint64 expiresAt, uint64 minLifetime)"),
+	[require_params.OperationType.TransferOwnership]: (0, viem.parseAbiParameters)("(bytes32 entityKey, address newOwner)"),
+	[require_params.OperationType.Delete]: (0, viem.parseAbiParameters)("(bytes32 entityKey)")
 };
 /** Creates an entity. The key is derived by the engine; predict it with `predictEntityKey`. */
 function createOperation({ salt, expiry, creationFlags, attributes }) {
 	return {
-		operation: require_expiry.OperationType.Create,
-		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.Create], [{
+		operation: require_params.OperationType.Create,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_params.OperationType.Create], [{
 			salt,
 			expiresAt: expiry.expiresAt,
 			minLifetime: expiry.minLifetime,
@@ -107,8 +86,8 @@ function createOperation({ salt, expiry, creationFlags, attributes }) {
 /** Applies a set of mutations to an existing entity. Tombstones unset attributes. */
 function patchOperation({ entityKey, mutations }) {
 	return {
-		operation: require_expiry.OperationType.Patch,
-		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.Patch], [{
+		operation: require_params.OperationType.Patch,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_params.OperationType.Patch], [{
 			entityKey,
 			mutations
 		}])
@@ -117,8 +96,8 @@ function patchOperation({ entityKey, mutations }) {
 /** Pushes an entity's expiry further out. Extending is allowed; shortening reverts. */
 function extendExpiryOperation({ entityKey, expiry }) {
 	return {
-		operation: require_expiry.OperationType.ExtendExpiry,
-		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.ExtendExpiry], [{
+		operation: require_params.OperationType.ExtendExpiry,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_params.OperationType.ExtendExpiry], [{
 			entityKey,
 			expiresAt: expiry.expiresAt,
 			minLifetime: expiry.minLifetime
@@ -128,8 +107,8 @@ function extendExpiryOperation({ entityKey, expiry }) {
 /** Hands an entity to a new owner. */
 function transferOwnershipOperation({ entityKey, newOwner }) {
 	return {
-		operation: require_expiry.OperationType.TransferOwnership,
-		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.TransferOwnership], [{
+		operation: require_params.OperationType.TransferOwnership,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_params.OperationType.TransferOwnership], [{
 			entityKey,
 			newOwner
 		}])
@@ -138,8 +117,8 @@ function transferOwnershipOperation({ entityKey, newOwner }) {
 /** Deletes an entity before its expiry. */
 function deleteOperation({ entityKey }) {
 	return {
-		operation: require_expiry.OperationType.Delete,
-		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.Delete], [{ entityKey }])
+		operation: require_params.OperationType.Delete,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_params.OperationType.Delete], [{ entityKey }])
 	};
 }
 
@@ -159,7 +138,7 @@ const logger$8 = require_query.getLogger("actions:public:get-entity-nonce");
 */
 async function getEntityNonce(client, owner) {
 	const nonce = await (0, viem_actions.readContract)(client, {
-		address: require_expiry.ARKIV_ADDRESS,
+		address: require_params.ARKIV_ADDRESS,
 		abi: ENTITY_NONCE_ABI,
 		functionName: "entityNonce",
 		args: [owner]
@@ -189,18 +168,19 @@ async function getEntityNonce(client, owner) {
 * @returns One `{ key, salt }` pair per create, in batch order. {@link PredictEntityKeysReturnType}
 *
 * @example A batch whose second entity points at its first.
-* import { key } from "@arkiv-network/sdk/attr"
+* import { defineSchema, key, str } from "@arkiv-network/sdk/schema"
+*
+* const Nodes = defineSchema("nodes", { name: str(), parent: key().indexed().optional() })
 *
 * const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
-* await client.executeBatch({
+* await wallet.executeBatch({
 *   creates: [
-*     { payload, contentType, expires, salt: parent.salt },
+*     { schema: Nodes, values: { name: "root" }, expiration, salt: parent.salt },
 *     {
-*       payload,
-*       contentType,
-*       expires,
+*       schema: Nodes,
+*       values: { name: "leaf", parent: key(parent.key) },
+*       expiration,
 *       salt: child.salt,
-*       attributes: { parent: key(parent.key) },
 *     },
 *   ],
 * })
@@ -235,20 +215,31 @@ function resolveSalts(count, salts) {
 /**
 * Runs a single query and returns one page, with no builder in between.
 *
+* The selection means what it does in `select()`, and each result is the same flat row a query
+* without a schema returns — typed from the selection, with every attribute an `ArkivValue` or
+* `undefined`.
+*
 * Takes either an {@link Expression} or a raw query string. The string form is an escape hatch for
 * a query built elsewhere — it goes to the node exactly as written, with none of the name, type or
 * operator checks the expression combinators apply.
 *
+* @throws If the selection asks for nothing, or names an attribute outside the name grammar.
 * @throws {QueryError} If the node rejects the query.
 */
-function query(client, query$1, options = {}) {
-	return require_query.runQuery(client, {
+async function query(client, query$1, options = {}) {
+	const projection = require_query.projectSelection(options.select);
+	const page = await require_query.runQuery(client, {
 		query: query$1.toString(),
-		select: require_query.toRpcSelect(options.select),
+		select: projection.select,
 		limit: options.limit,
 		cursor: options.cursor,
-		atBlock: options.atBlock
+		atBlock: options.atBlock,
+		count: options.count
 	});
+	return {
+		...page,
+		entities: page.entities.map((entity) => require_query.toRow(entity, projection))
+	};
 }
 
 //#endregion
@@ -260,7 +251,7 @@ const logger$7 = require_query.getLogger("actions:public:watch-entity-events");
 * Half a block: fast enough that an event is never a whole block stale, slow enough not to hammer
 * the node. viem's own default is derived from a 12-second Ethereum block and is far too slow here.
 */
-const DEFAULT_POLLING_INTERVAL = require_expiry.BLOCK_TIME * 1e3 / 2;
+const DEFAULT_POLLING_INTERVAL = require_params.BLOCK_TIME * 1e3 / 2;
 /**
 * Watches entity events, calling the handlers you pass as they arrive.
 *
@@ -327,7 +318,7 @@ function watchEntityEvents(client, parameters) {
 		}
 	}
 	return publicClient.watchEvent({
-		address: require_expiry.ARKIV_ADDRESS,
+		address: require_params.ARKIV_ADDRESS,
 		events: require_entity$1.ENTITY_EVENTS_ABI,
 		pollingInterval,
 		...fromBlock !== void 0 && { fromBlock },
@@ -377,7 +368,7 @@ function toEntityEvent(topics, data, context) {
 			type: "EntityCreated",
 			...context,
 			...decoded.args,
-			creationFlags: require_flags.decodeCreationFlags(decoded.args.creationFlags)
+			creationFlags: require_query.decodeCreationFlags(decoded.args.creationFlags)
 		};
 		case "EntityPatched": return {
 			type: "EntityPatched",
@@ -406,11 +397,11 @@ function toEntityEvent(topics, data, context) {
 //#region src/clients/decorators/arkivPublic.ts
 function publicArkivActions(client) {
 	return {
-		getEntity: (key$1) => getEntity(client, key$1),
-		query: (rawQuery, queryOptions) => query(client, rawQuery, queryOptions),
-		select: (selection) => new require_query.SelectQueryBuilder(client, selection),
+		getEntity: ((key$1, schema) => getEntity(client, key$1, schema)),
+		query: ((rawQuery, queryOptions) => query(client, rawQuery, queryOptions)),
+		select: ((selection) => new require_query.SelectQueryBuilder(client, selection)),
+		count: () => new require_query.CountQueryBuilder(client),
 		getBlockTiming: () => getBlockTiming(client),
-		getEntityCount: () => getEntityCount(client),
 		getEntityNonce: (owner) => getEntityNonce(client, owner),
 		predictEntityKeys: (parameters) => predictEntityKeys(client, parameters),
 		watchEntityEvents: (parameters) => watchEntityEvents(client, parameters)
@@ -479,10 +470,10 @@ function explain(name, args) {
 			return `an attribute name holds ${printable(String(args[1] ?? "0x00"))} at byte ${position}, which is outside the name charset (${CHARSET})`;
 		}
 		case "Ident32Empty": return "an attribute name is empty";
-		case "SystemAttributeNotWritable": return `"${identName(args[0])}" is owned by the engine and cannot be written. Only $payload and \$contentType are yours to set`;
+		case "SystemAttributeNotWritable": return `"${identName(args[0])}" is owned by the engine and cannot be written. Names starting with "\$" are reserved for system attributes`;
 		case "TombstoneInCreate": return `a create cannot unset "${identName(args[0])}" — nothing exists yet, so leave the name out instead`;
 		case "TombstoneValueNotEmpty": return `the tombstone for "${identName(args[0])}" carries a value; unsetting takes no value`;
-		case "InvalidValueType": return `"${identName(args[0])}" names type id ${String(args[1])}, which is not a known type`;
+		case "InvalidValueType": return describeInvalidType(identName(args[0]), Number(args[1]));
 		case "AttributesNotSorted": return "attributes must be strictly ascending by name, which also makes each name unique";
 		case "TooManyAttributes": return `${String(args[0])} attributes exceeds the limit of ${String(args[1])}`;
 		case "EmptyMutations": return `the patch of ${short(args[0])} has no mutations, so it would do nothing`;
@@ -501,6 +492,19 @@ function explain(name, args) {
 		default: return;
 	}
 }
+/**
+* Why the engine refused a `typeId` — an indexed `bytes`, a known type it would not take (most
+* likely the indexed flag, on a node that predates it), or a type it does not know.
+*/
+function describeInvalidType(name, typeId) {
+	try {
+		const { tag, indexed } = require_schema.decodeTypeId(typeId);
+		if (tag === "bytes" && indexed) return `"${name}" is a bytes attribute flagged as indexed, and bytes are stored but never indexed`;
+		if (indexed) return `"${name}" has type ${tag} and is flagged as indexed (type id ${typeId}), which the node does not accept. The node may not support the indexed flag yet`;
+		return `"${name}" has type ${tag} (type id ${typeId}), which the node does not accept`;
+	} catch {}
+	return `"${name}" names type id ${typeId}, which is not a known type`;
+}
 /** A `bytes32` Ident32 cell as the name it holds — left-aligned, null-padded. */
 function identName(raw) {
 	if (typeof raw !== "string") return String(raw);
@@ -525,10 +529,6 @@ function printable(byte) {
 //#endregion
 //#region src/utils/arkivTransactions.ts
 const logger$6 = require_query.getLogger("utils:arkiv-transactions");
-const MIME_REGEX = /^[a-z][a-z0-9!#$&\-^_]*\/[a-z0-9][a-z0-9!#$&\-^_.+]*$/;
-function validateContentType(contentType) {
-	if (!MIME_REGEX.test(contentType)) throw new require_query.InvalidContentTypeError(contentType);
-}
 const ENTITY_ERRORS_ABI = (0, viem.parseAbi)([
 	"error EmptyBatch()",
 	"error InvalidOpType(uint8 operation)",
@@ -558,30 +558,29 @@ async function sendArkivTransaction(client, ops, txParams) {
 	if (!client.chain) throw new Error("Chain required");
 	const walletClient = client;
 	const { creates, patches, deletes, extensions, ownershipChanges } = ops;
-	const expiryContext = { currentBlock: creates?.length || extensions?.length ? await walletClient.getBlockNumber() : 0n };
-	const createOps = (creates ?? []).map((item) => {
-		validateContentType(item.contentType);
-		return createOperation({
-			salt: item.salt === void 0 ? require_entity$1.randomSalt() : require_entity$1.resolveSalt(item.salt),
-			expiry: require_expiry.resolveExpiry(item.expires, expiryContext),
-			creationFlags: require_flags.encodeCreationFlags(item.flags),
-			attributes: require_attr.encodeAttributes(item.attributes, {
-				payload: item.payload,
-				contentType: item.contentType
-			})
-		});
-	});
+	const encodedCreates = (creates ?? []).map((item) => ({
+		item,
+		attributes: require_schema.encodeCreate(item.schema, item.values)
+	}));
 	const patchOps = (patches ?? []).map((item) => {
-		if (item.contentType !== void 0) validateContentType(item.contentType);
-		const mutations = require_attr.encodeMutations(item);
+		const mutations = require_schema.encodePatch(item.schema, item);
 		if (mutations.length === 0) throw new require_query.EmptyPatchError(item.entityKey);
 		return patchOperation({
 			entityKey: item.entityKey,
 			mutations
 		});
 	});
+	const expiryContext = { currentBlock: creates?.length || extensions?.length ? await walletClient.getBlockNumber() : 0n };
+	const createOps = encodedCreates.map(({ item, attributes }) => {
+		return createOperation({
+			salt: item.salt === void 0 ? require_entity$1.randomSalt() : require_entity$1.resolveSalt(item.salt),
+			expiry: require_expirationTime.resolveExpiry(item.expiration, expiryContext),
+			creationFlags: require_query.encodeCreationFlags(item.flags),
+			attributes
+		});
+	});
 	const extendOps = (extensions ?? []).map((item) => {
-		const expiry = require_expiry.resolveExpiry(item.expires, expiryContext);
+		const expiry = require_expirationTime.resolveExpiry(item.expiration, expiryContext);
 		return extendExpiryOperation({
 			entityKey: item.entityKey,
 			expiry
@@ -602,7 +601,7 @@ async function sendArkivTransaction(client, ops, txParams) {
 	let txHash;
 	try {
 		txHash = await walletClient.writeContract({
-			address: require_expiry.ARKIV_ADDRESS,
+			address: require_params.ARKIV_ADDRESS,
 			abi: EXECUTE_ABI$1,
 			functionName: "execute",
 			args: [operations],
@@ -615,7 +614,7 @@ async function sendArkivTransaction(client, ops, txParams) {
 		if (receipt.status === "reverted") {
 			try {
 				await walletClient.simulateContract({
-					address: require_expiry.ARKIV_ADDRESS,
+					address: require_params.ARKIV_ADDRESS,
 					abi: EXECUTE_ABI$1,
 					functionName: "execute",
 					args: [operations],
@@ -667,7 +666,7 @@ function readAppliedOperations(receipt, expected) {
 	const createdExpiries = [];
 	const extendedExpiries = [];
 	for (const log of receipt.logs ?? []) {
-		if (log.address.toLowerCase() !== require_expiry.ARKIV_ADDRESS.toLowerCase()) continue;
+		if (log.address.toLowerCase() !== require_params.ARKIV_ADDRESS.toLowerCase()) continue;
 		const decoded = decodeEntityLog(log);
 		if (decoded === void 0) continue;
 		if (decoded.eventName === "EntityCreated") {
@@ -716,9 +715,13 @@ async function changeOwnership(client, data, txParams) {
 //#endregion
 //#region src/actions/wallet/createEntity.ts
 const logger$4 = require_query.getLogger("actions:wallet:create-entity");
-async function createEntity(client, data, txParams) {
-	logger$4("createEntity %o", data);
-	const { receipt, createdEntityKeys, createdExpiries } = await sendArkivTransaction(client, { creates: [data] }, txParams);
+async function createEntity(client, schema, values, options, txParams) {
+	logger$4("createEntity %o", values);
+	const { receipt, createdEntityKeys, createdExpiries } = await sendArkivTransaction(client, { creates: [{
+		...options,
+		schema,
+		values
+	}] }, txParams);
 	logger$4("Receipt from createEntity %o", receipt);
 	const [entityKey] = createdEntityKeys;
 	const [expiresAt] = createdExpiries;
@@ -778,13 +781,17 @@ async function extendEntity(client, data, txParams) {
 //#endregion
 //#region src/actions/wallet/patchEntity.ts
 const logger = require_query.getLogger("actions:wallet:patch-entity");
-async function patchEntity(client, data, txParams) {
-	logger("patchEntity %o", data);
-	const { receipt } = await sendArkivTransaction(client, { patches: [data] }, txParams);
+async function patchEntity(client, schema, entityKey, changes, txParams) {
+	logger("patchEntity %s %o", entityKey, changes);
+	const { receipt } = await sendArkivTransaction(client, { patches: [{
+		...changes,
+		schema,
+		entityKey
+	}] }, txParams);
 	logger("Receipt from patchEntity %o", receipt);
 	return {
 		txHash: receipt.transactionHash,
-		entityKey: data.entityKey
+		entityKey
 	};
 }
 
@@ -792,8 +799,8 @@ async function patchEntity(client, data, txParams) {
 //#region src/clients/decorators/arkivWallet.ts
 function walletArkivActions(client) {
 	return {
-		createEntity: (data, txParams) => createEntity(client, data, txParams),
-		patchEntity: (data, txParams) => patchEntity(client, data, txParams),
+		createEntity: (schema, values, options, txParams) => createEntity(client, schema, values, options, txParams),
+		patchEntity: (schema, entityKey, changes, txParams) => patchEntity(client, schema, entityKey, changes, txParams),
 		deleteEntity: (data, txParams) => deleteEntity(client, data, txParams),
 		extendEntity: (data, txParams) => extendEntity(client, data, txParams),
 		changeOwnership: (data, txParams) => changeOwnership(client, data, txParams),
@@ -809,7 +816,10 @@ function walletArkivActions(client) {
 *
 * A Wallet Client signs and sends transactions, so it carries an `account` and exposes everything
 * that mutates state — `createEntity`, `patchEntity`, `deleteEntity`, `extendEntity`,
-* `changeOwnership` and `executeBatch` — on top of the read actions a Public Client has.
+* `changeOwnership` and `executeBatch` — alongside the viem actions those need, such as
+* `getBlockNumber`, `readContract` and `waitForTransactionReceipt`. It does not have the Arkiv
+* read actions (`getEntity`, `query`, `select`, `watchEntityEvents`, `predictEntityKeys`); read
+* through a Public Client from `createPublicClient` for those.
 *
 * @param parameters - Configuration object for the wallet client (chain, transport, account, etc.)
 * @returns An Arkiv Wallet Client. {@link WalletArkivClient}
@@ -851,63 +861,69 @@ function chainFromName(name) {
 }
 
 //#endregion
-exports.ConflictingMutationError = require_attr.ConflictingMutationError;
-exports.DECIMAL_SCALE = require_attr.DECIMAL_SCALE;
-exports.DECIMAL_UNIT = require_attr.DECIMAL_UNIT;
+exports.ConflictingMutationError = require_schema.ConflictingMutationError;
+exports.CountQueryBuilder = require_query.CountQueryBuilder;
+exports.DECIMAL_SCALE = require_schema.DECIMAL_SCALE;
+exports.DECIMAL_UNIT = require_schema.DECIMAL_UNIT;
 exports.ENTITY_EVENTS_ABI = require_entity$1.ENTITY_EVENTS_ABI;
 exports.EmptyPatchError = require_query.EmptyPatchError;
 exports.Entity = require_entity.Entity;
 exports.EntityMutationError = require_query.EntityMutationError;
-exports.ExpirationTime = require_payload.ExpirationTime;
-exports.I32_MAX = require_attr.I32_MAX;
-exports.I32_MIN = require_attr.I32_MIN;
-exports.InvalidAttributeNameError = require_attr.InvalidAttributeNameError;
-exports.InvalidContentTypeError = require_query.InvalidContentTypeError;
+exports.EntityTooLargeError = require_schema.EntityTooLargeError;
+exports.ExpirationTime = require_expirationTime.ExpirationTime;
+exports.I32_MAX = require_schema.I32_MAX;
+exports.I32_MIN = require_schema.I32_MIN;
+exports.INDEXED_FLAG = require_schema.INDEXED_FLAG;
+exports.InvalidAttributeNameError = require_schema.InvalidAttributeNameError;
 exports.InvalidCreationFlagsError = require_errors.InvalidCreationFlagsError;
 exports.InvalidExpiryError = require_errors.InvalidExpiryError;
 exports.InvalidSaltError = require_errors.InvalidSaltError;
-exports.InvalidValueError = require_attr.InvalidValueError;
-exports.MAX_ATTRIBUTES = require_attr.MAX_ATTRIBUTES;
-exports.MAX_EXPIRES_AT = require_expiry.MAX_EXPIRES_AT;
-exports.MAX_NAME_BYTES = require_attr.MAX_NAME_BYTES;
-exports.MAX_PAYLOAD_BYTES = require_attr.MAX_PAYLOAD_BYTES;
+exports.InvalidValueError = require_schema.InvalidValueError;
+exports.MAX_ATTRIBUTES = require_schema.MAX_ATTRIBUTES;
+exports.MAX_BYTES_LENGTH = require_schema.MAX_BYTES_LENGTH;
+exports.MAX_ENTITY_BYTES = require_schema.MAX_ENTITY_BYTES;
+exports.MAX_EXPIRES_AT = require_params.MAX_EXPIRES_AT;
+exports.MAX_NAME_BYTES = require_schema.MAX_NAME_BYTES;
 exports.MAX_SALT = require_entity$1.MAX_SALT;
-exports.MAX_STRING_BYTES = require_attr.MAX_STRING_BYTES;
-exports.MissingValueError = require_attr.MissingValueError;
+exports.MAX_STRING_BYTES = require_schema.MAX_STRING_BYTES;
+exports.MissingValueError = require_schema.MissingValueError;
 exports.NO_SALT = require_entity$1.NO_SALT;
 exports.NoEntityFoundError = require_query.NoEntityFoundError;
 exports.NoMoreResultsError = require_query.NoMoreResultsError;
 exports.NoRandomSourceError = require_errors.NoRandomSourceError;
-exports.OperationType = require_expiry.OperationType;
+exports.SCHEMA_ATTRIBUTE = require_schema.SCHEMA_ATTRIBUTE;
+exports.SYSTEM_FIELDS = require_query.SYSTEM_FIELDS;
+exports.SchemaDefinitionError = require_schema.SchemaDefinitionError;
+exports.SchemaMismatchError = require_schema.SchemaMismatchError;
 exports.SelectQueryBuilder = require_query.SelectQueryBuilder;
-exports.TooManyAttributesError = require_attr.TooManyAttributesError;
-exports.U256_MAX = require_attr.U256_MAX;
-exports.U64_MAX = require_attr.U64_MAX;
-exports.UnknownAttributeTypeError = require_attr.UnknownAttributeTypeError;
-exports.UntypedValueError = require_attr.UntypedValueError;
-exports.addr = require_attr.addr;
-exports.bool = require_attr.bool;
-exports.bytes32 = require_attr.bytes32;
+exports.TooManyAttributesError = require_schema.TooManyAttributesError;
+exports.U256_MAX = require_schema.U256_MAX;
+exports.U64_MAX = require_schema.U64_MAX;
+exports.UnknownAttributeTypeError = require_schema.UnknownAttributeTypeError;
+exports.UntypedValueError = require_schema.UntypedValueError;
+exports.addr = require_schema.addr;
+exports.bool = require_schema.bool;
+exports.bytes = require_schema.bytes;
+exports.bytes32 = require_schema.bytes32;
 exports.chainFromName = chainFromName;
 exports.createPublicClient = createPublicClient;
 exports.createWalletClient = createWalletClient;
-exports.dec = require_attr.dec;
-exports.decFromUnits = require_attr.decFromUnits;
-exports.decUnits = require_attr.decUnits;
-exports.decodeCreationFlags = require_flags.decodeCreationFlags;
-exports.encodeCreationFlags = require_flags.encodeCreationFlags;
-exports.i32 = require_attr.i32;
-exports.isArkivValue = require_attr.isArkivValue;
-exports.isValidAttributeName = require_attr.isValidAttributeName;
-exports.jsonToPayload = require_payload.jsonToPayload;
-exports.key = require_attr.key;
+exports.dec = require_schema.dec;
+exports.decFromUnits = require_schema.decFromUnits;
+exports.decUnits = require_schema.decUnits;
+exports.defineSchema = require_schema.defineSchema;
+exports.describeColumns = require_schema.describeColumns;
+exports.i32 = require_schema.i32;
+exports.isArkivValue = require_schema.isArkivValue;
+exports.isColumn = require_schema.isColumn;
+exports.isSchema = require_schema.isSchema;
+exports.isValidAttributeName = require_schema.isValidAttributeName;
+exports.key = require_schema.key;
+exports.lookupColumn = require_schema.lookupColumn;
 exports.predictEntityKey = require_entity$1.predictEntityKey;
 exports.randomSalt = require_entity$1.randomSalt;
-exports.resolveExpiry = require_expiry.resolveExpiry;
-exports.str = require_attr.str;
-exports.stringToPayload = require_payload.stringToPayload;
-exports.toBlocks = require_expiry.toBlocks;
-exports.toValue = require_attr.toValue;
-exports.u256 = require_attr.u256;
-exports.u64 = require_attr.u64;
-exports.validateAttributeName = require_attr.validateAttributeName;
+exports.str = require_schema.str;
+exports.toValue = require_schema.toValue;
+exports.u256 = require_schema.u256;
+exports.u64 = require_schema.u64;
+exports.validateAttributeName = require_schema.validateAttributeName;