@ocap/state 1.28.9 → 1.29.1

package/esm/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll };

package/esm/contexts/state.d.mts

@@ -0,0 +1,15 @@
+import { IStateContext, IStateContextInput } from "@ocap/types";
+
+//#region src/contexts/state.d.ts
+type StateContextInput = IStateContextInput;
+type StateContext = IStateContext;
+declare const create: ({
+  txHash,
+  txTime
+}: StateContextInput) => StateContext;
+declare const update: (context: StateContext, {
+  txHash,
+  txTime
+}: StateContextInput) => StateContext;
+//#endregion
+export { StateContext, StateContextInput, create, update };

package/esm/contexts/state.mjs

@@ -0,0 +1,17 @@
+//#region src/contexts/state.ts
+const create = ({ txHash, txTime }) => ({
+	genesisTime: txTime || "",
+	genesisTx: txHash || "",
+	renaissanceTime: txTime || "",
+	renaissanceTx: txHash || ""
+});
+const update = (context, { txHash, txTime }) => ({
+	...context,
+	genesisTime: context.genesisTime || "2020-01-15T00:00:00.000Z",
+	genesisTx: context.genesisTx || "",
+	renaissanceTime: txTime || "",
+	renaissanceTx: txHash || ""
+});
+
+//#endregion
+export { create, update };

package/esm/index.d.mts

@@ -0,0 +1,20 @@
+import { account_d_exports } from "./states/account.mjs";
+import { asset_d_exports } from "./states/asset.mjs";
+import { ChainState, chain_d_exports } from "./states/chain.mjs";
+import { delegation_d_exports } from "./states/delegation.mjs";
+import { evidence_d_exports } from "./states/evidence.mjs";
+import { factory_d_exports } from "./states/factory.mjs";
+import { rollup_d_exports } from "./states/rollup.mjs";
+import { rollup_block_d_exports } from "./states/rollup-block.mjs";
+import { stake_d_exports } from "./states/stake.mjs";
+import { token_d_exports } from "./states/token.mjs";
+import { token_factory_d_exports } from "./states/token-factory.mjs";
+import { ItxJson, Receipt, ReceiptChange, TokenInput, TxContext, TxData, TxInput, TxOutput, TxResult, tx_d_exports } from "./states/tx.mjs";
+import Blacklist, { BlacklistOptions, TrustedAccountConfig } from "./states/blacklist.mjs";
+
+//#region src/index.d.ts
+
+declare const indexes: readonly ["account", "asset", "delegation", "tx", "factory", "token", "stake", "rollup", "rollupBlock", "rollupValidator", "tokenDistribution", "tokenFactory"];
+declare const tables: readonly ["chain", "account", "asset", "delegation", "tx", "factory", "token", "stake", "rollup", "rollupBlock", "evidence", "balance", "tokenFactory"];
+//#endregion
+export { Blacklist, type BlacklistOptions, type ChainState, type ItxJson, type Receipt, type ReceiptChange, type TokenInput, type TrustedAccountConfig, type TxContext, type TxData, type TxInput, type TxOutput, type TxResult, account_d_exports as account, asset_d_exports as asset, chain_d_exports as chain, delegation_d_exports as delegation, evidence_d_exports as evidence, factory_d_exports as factory, indexes, rollup_d_exports as rollup, rollup_block_d_exports as rollupBlock, stake_d_exports as stake, tables, token_d_exports as token, token_factory_d_exports as tokenFactory, tx_d_exports as tx };

package/esm/index.mjs

@@ -0,0 +1,47 @@
+import { account_exports } from "./states/account.mjs";
+import { asset_exports } from "./states/asset.mjs";
+import { chain_exports } from "./states/chain.mjs";
+import { delegation_exports } from "./states/delegation.mjs";
+import { evidence_exports } from "./states/evidence.mjs";
+import { factory_exports } from "./states/factory.mjs";
+import { rollup_exports } from "./states/rollup.mjs";
+import { rollup_block_exports } from "./states/rollup-block.mjs";
+import { stake_exports } from "./states/stake.mjs";
+import { token_exports } from "./states/token.mjs";
+import { token_factory_exports } from "./states/token-factory.mjs";
+import { tx_exports } from "./states/tx.mjs";
+import blacklist_default from "./states/blacklist.mjs";
+
+//#region src/index.ts
+const indexes = [
+	"account",
+	"asset",
+	"delegation",
+	"tx",
+	"factory",
+	"token",
+	"stake",
+	"rollup",
+	"rollupBlock",
+	"rollupValidator",
+	"tokenDistribution",
+	"tokenFactory"
+];
+const tables = [
+	"chain",
+	"account",
+	"asset",
+	"delegation",
+	"tx",
+	"factory",
+	"token",
+	"stake",
+	"rollup",
+	"rollupBlock",
+	"evidence",
+	"balance",
+	"tokenFactory"
+];
+
+//#endregion
+export { blacklist_default as Blacklist, account_exports as account, asset_exports as asset, chain_exports as chain, delegation_exports as delegation, evidence_exports as evidence, factory_exports as factory, indexes, rollup_exports as rollup, rollup_block_exports as rollupBlock, stake_exports as stake, tables, token_exports as token, token_factory_exports as tokenFactory, tx_exports as tx };

package/esm/states/account.d.mts

@@ -0,0 +1,18 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { IAccountState } from "@ocap/types";
+
+//#region src/states/account.d.ts
+declare namespace account_d_exports {
+  export { create, ensureChecksumAddress, isMigrated, schema, update, updateOrCreate, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IAccountState>, context: StateContextInput) => IAccountState;
+declare const update: (state: IAccountState, attrs: Partial<IAccountState>, context: StateContextInput) => IAccountState;
+declare const updateOrCreate: (state: IAccountState | null, attrs: Partial<IAccountState>, context: StateContextInput) => IAccountState;
+declare const validate: (state: IAccountState) => IAccountState;
+declare const isMigrated: (state: {
+  migratedTo?: string[];
+}) => boolean;
+declare const ensureChecksumAddress: (address: string) => string;
+//#endregion
+export { account_d_exports, create, ensureChecksumAddress, isMigrated, schema, update, updateOrCreate, validate };

package/esm/states/account.mjs

@@ -0,0 +1,91 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { isFromPublicKey } from "@arcblock/did";
+import { isEthereumDid, toChecksumAddress } from "@arcblock/did/lib/type";
+import { BN, toAddress, toBase58 } from "@ocap/util";
+import { CustomError } from "@ocap/util/lib/error";
+import flatten from "lodash/flatten.js";
+import pick from "lodash/pick.js";
+import uniq from "lodash/uniq.js";
+import { Joi, schemas } from "@arcblock/validator";
+
+//#region src/states/account.ts
+var account_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	ensureChecksumAddress: () => ensureChecksumAddress,
+	isMigrated: () => isMigrated,
+	schema: () => schema,
+	update: () => update,
+	updateOrCreate: () => updateOrCreate,
+	validate: () => validate
+});
+const schema = Joi.object({
+	address: Joi.DID().prefix().required(),
+	pk: Joi.string().allow(null).allow(""),
+	issuer: Joi.DID().prefix().allow(null).allow(""),
+	moniker: Joi.string().regex(/^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/).allow(""),
+	nonce: Joi.number().min(0).default(0),
+	tokens: Joi.object().pattern(Joi.DID().prefix().role("ROLE_TOKEN"), Joi.BN().min(0)).default({}),
+	migratedTo: Joi.array().items(Joi.DID().prefix()).default([]),
+	migratedFrom: Joi.array().items(Joi.DID().prefix()).default([]),
+	context: schemas.context,
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	const account = {
+		nonce: 0,
+		migratedTo: uniq([].concat(attrs.migratedTo || [])),
+		migratedFrom: [],
+		tokens: {},
+		context: create$1(context),
+		...pick(attrs, [
+			"address",
+			"pk",
+			"issuer",
+			"moniker",
+			"data",
+			"nonce",
+			"migratedFrom",
+			"tokens"
+		])
+	};
+	account.address = toAddress(ensureChecksumAddress(account.address));
+	if (!account.moniker) account.moniker = [account.address.slice(0, 6), account.address.slice(-5)].join("-");
+	return validate(account);
+};
+const update = (state, attrs, context) => {
+	if (attrs.nonce && new BN(attrs.nonce).eq(new BN(state.nonce))) throw new CustomError("INVALID_NONCE", "nonce must be greater in newer transactions");
+	if (attrs.pk && isFromPublicKey(state.address, attrs.pk) === false) delete attrs.pk;
+	return validate({
+		...state,
+		...pick(attrs, [
+			"moniker",
+			"data",
+			"migratedTo",
+			"nonce",
+			"tokens",
+			"pk"
+		]),
+		migratedTo: uniq(flatten(attrs.migratedTo ? [attrs.migratedTo].concat(state.migratedTo) : state.migratedTo)),
+		context: update$1(state.context, context)
+	});
+};
+const updateOrCreate = (state, attrs, context) => {
+	if (state) return update(state, attrs, context);
+	return create(attrs, context);
+};
+const validate = (state) => {
+	if (state.pk && typeof state.pk !== "string") state.pk = toBase58(state.pk);
+	const { value, error } = schema.validate(state);
+	if (error) throw new CustomError("INVALID_ACCOUNT", `Invalid account: ${error.details.map((x) => x.message).join(", ")}`);
+	if (!value.data) value.data = null;
+	return value;
+};
+const isMigrated = (state) => (state.migratedTo || []).length > 0;
+const ensureChecksumAddress = (address) => isEthereumDid(address) ? toChecksumAddress(address) : address;
+
+//#endregion
+export { account_exports, create, ensureChecksumAddress, isMigrated, schema, update, updateOrCreate, validate };

package/esm/states/asset.d.mts

@@ -0,0 +1,14 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { schemas } from "@arcblock/validator";
+import { IAssetState } from "@ocap/types";
+
+//#region src/states/asset.d.ts
+declare namespace asset_d_exports {
+  export { create, schema, schemas, update, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IAssetState>, context: StateContextInput) => IAssetState;
+declare const update: (state: IAssetState, attrs: Partial<IAssetState>, context: StateContextInput) => IAssetState;
+declare const validate: (state: IAssetState) => IAssetState;
+//#endregion
+export { asset_d_exports, create, schema, schemas, update, validate };

package/esm/states/asset.mjs

@@ -0,0 +1,80 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { toAddress } from "@ocap/util";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import { Joi, schemas } from "@arcblock/validator";
+
+//#region src/states/asset.ts
+var asset_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	schema: () => schema,
+	schemas: () => schemas,
+	update: () => update,
+	validate: () => validate
+});
+const stateSchema = Joi.object({
+	...schemas.assetProps,
+	owner: Joi.DID().prefix().required(),
+	consumedTime: Joi.date().iso().raw().allow(""),
+	context: schemas.context
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const schema = schemas.assetSchema;
+const create = (attrs, context) => {
+	const asset = {
+		consumedTime: "",
+		issuer: "",
+		parent: "",
+		readonly: false,
+		transferrable: true,
+		ttl: 0,
+		tags: [],
+		context: create$1(context),
+		...pick(attrs, [
+			"address",
+			"owner",
+			"issuer",
+			"moniker",
+			"parent",
+			"data",
+			"readonly",
+			"transferrable",
+			"ttl",
+			"endpoint",
+			"display",
+			"tags"
+		])
+	};
+	if (asset.tags === null) asset.tags = [];
+	asset.address = toAddress(asset.address);
+	return validate(asset);
+};
+const update = (state, attrs, context) => {
+	const asset = {
+		...state,
+		...pick(attrs, [
+			"moniker",
+			"data",
+			"owner",
+			"consumedTime"
+		]),
+		context: update$1(state.context, context)
+	};
+	if (asset.tags === null) asset.tags = [];
+	if (!asset.consumedTime) asset.consumedTime = "";
+	return validate(asset);
+};
+const validate = (state) => {
+	const { value, error } = stateSchema.validate(state);
+	if (error) throw new CustomError("INVALID_ASSET", `Invalid asset: ${error.details.map((x) => x.message).join(", ")}`);
+	["endpoint", "display"].forEach((key) => {
+		if (!value[key]) delete value[key];
+	});
+	return value;
+};
+
+//#endregion
+export { asset_exports, create, schema, schemas, update, validate };

package/esm/states/blacklist.d.mts

@@ -0,0 +1,36 @@
+//#region src/states/blacklist.d.ts
+interface TrustedAccountConfig {
+  address: string;
+  [key: string]: unknown;
+}
+interface BlacklistOptions {
+  size?: number;
+  numHashFns?: number;
+  dumpPath?: string;
+  dumpInterval?: number;
+  getBlockedAccounts?: (() => Promise<string[]>) | null;
+  getTrustedAccounts?: (() => Promise<TrustedAccountConfig[]>) | null;
+}
+declare class Blacklist {
+  private dumpPath;
+  private filter;
+  private getBlockedAccounts;
+  private getTrustedAccounts;
+  private timer?;
+  constructor({
+    size,
+    numHashFns,
+    dumpPath,
+    dumpInterval,
+    getBlockedAccounts,
+    getTrustedAccounts
+  }?: BlacklistOptions);
+  has(key: string): boolean;
+  add(key: string): void;
+  isBlocked(address: string): Promise<boolean>;
+  isTrusted(address: string): Promise<boolean>;
+  getTrustedAccountConfig(address: string): Promise<TrustedAccountConfig | null | undefined>;
+  dump(): void;
+}
+//#endregion
+export { BlacklistOptions, TrustedAccountConfig, Blacklist as default };

package/esm/states/blacklist.mjs

@@ -0,0 +1,71 @@
+import { isSameDid } from "@ocap/util";
+import { CustomError } from "@ocap/util/lib/error";
+import fs from "node:fs";
+import { BloomFilter } from "bloom-filters";
+
+//#region src/states/blacklist.ts
+var Blacklist = class {
+	constructor({ size = 256, numHashFns = 4, dumpPath = "", dumpInterval = 0, getBlockedAccounts = null, getTrustedAccounts = null } = {}) {
+		let filter;
+		if (dumpPath && fs.existsSync(dumpPath)) try {
+			const json = JSON.parse(fs.readFileSync(dumpPath, "utf-8"));
+			filter = BloomFilter.fromJSON(json);
+		} catch (_err) {
+			throw new CustomError("INTERNAL", `Cat not read serialized blacklist from json${dumpPath}`);
+		}
+		if (!filter) filter = new BloomFilter(size, numHashFns);
+		this.dumpPath = dumpPath;
+		this.filter = filter;
+		this.getBlockedAccounts = getBlockedAccounts;
+		this.getTrustedAccounts = getTrustedAccounts;
+		if (dumpPath && dumpInterval > 0) {
+			this.timer = setTimeout(() => {
+				this.dump();
+				this.timer = setTimeout(() => {
+					this.dump();
+				}, dumpInterval);
+				this.timer.unref();
+			}, dumpInterval);
+			this.timer.unref();
+			process.on("beforeExit", () => {
+				this.dump();
+			});
+		}
+	}
+	has(key) {
+		return this.filter.has(key);
+	}
+	add(key) {
+		this.filter.add(key);
+	}
+	async isBlocked(address) {
+		if (typeof this.getBlockedAccounts === "function") {
+			const blocked = await this.getBlockedAccounts();
+			if (blocked.length) return blocked.some((b) => isSameDid(b, address));
+		}
+		return false;
+	}
+	async isTrusted(address) {
+		if (typeof this.getTrustedAccounts === "function") {
+			const trustedAccounts = await this.getTrustedAccounts();
+			if (trustedAccounts.length) return trustedAccounts.some((b) => isSameDid(b.address, address));
+		}
+		return false;
+	}
+	async getTrustedAccountConfig(address) {
+		if (typeof this.getTrustedAccounts === "function") return (await this.getTrustedAccounts()).find((x) => isSameDid(x.address, address));
+		return null;
+	}
+	dump() {
+		try {
+			const exported = this.filter.saveAsJSON();
+			const tmpFile = `${this.dumpPath}~`;
+			fs.writeFileSync(tmpFile, JSON.stringify(exported));
+			fs.renameSync(tmpFile, this.dumpPath);
+		} catch (_err) {}
+	}
+};
+var blacklist_default = Blacklist;
+
+//#endregion
+export { blacklist_default as default };

package/esm/states/chain.d.mts

@@ -0,0 +1,30 @@
+import { StateContext } from "../contexts/state.mjs";
+
+//#region src/states/chain.d.ts
+declare namespace chain_d_exports {
+  export { ChainState, create, update };
+}
+interface ChainState {
+  address?: string;
+  chainId?: string;
+  version?: string;
+  transaction?: unknown;
+  moderator?: unknown;
+  accounts?: unknown;
+  token?: {
+    symbol?: string;
+    decimal?: number;
+    name?: string;
+    description?: string;
+    unit?: string;
+    totalSupply?: string;
+    initialSupply?: string;
+    foreignToken?: unknown;
+  };
+  vaults?: unknown;
+  context: StateContext;
+}
+declare const create: (attrs: Partial<ChainState>) => ChainState;
+declare const update: (state: ChainState, updates: Partial<ChainState>) => ChainState;
+//#endregion
+export { ChainState, chain_d_exports, create, update };

package/esm/states/chain.mjs

@@ -0,0 +1,52 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import get from "lodash/get.js";
+import isEqual from "lodash/isEqual.js";
+
+//#region src/states/chain.ts
+var chain_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	update: () => update
+});
+const create = (attrs) => {
+	return {
+		context: create$1({ txTime: (/* @__PURE__ */ new Date()).toISOString() }),
+		...pick(attrs, [
+			"address",
+			"chainId",
+			"version",
+			"transaction",
+			"moderator",
+			"accounts",
+			"token",
+			"vaults"
+		])
+	};
+};
+const update = (state, updates) => {
+	const immutableAttrs = [
+		"chainId",
+		"moderator",
+		"token.symbol",
+		"token.decimal"
+	];
+	if (!process.env.CHAIN_TOKEN_ADDRESS) immutableAttrs.push("token.name", "token.description", "token.unit", "token.totalSupply", "token.initialSupply", "token.foreignToken");
+	for (const attr of immutableAttrs) if (get(updates, attr) && !isEqual(get(updates, attr), get(state, attr))) throw new CustomError("FORBIDDEN", `Cannot update ${attr} field on chain state`);
+	const context = { txTime: (/* @__PURE__ */ new Date()).toISOString() };
+	return {
+		...state,
+		...pick(updates, [
+			"version",
+			"transaction",
+			"accounts",
+			"vaults",
+			"token"
+		]),
+		context: update$1(state.context, context)
+	};
+};
+
+//#endregion
+export { chain_exports, create, update };

package/esm/states/delegation.d.mts

@@ -0,0 +1,11 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { IDelegateState } from "@ocap/types";
+
+//#region src/states/delegation.d.ts
+declare namespace delegation_d_exports {
+  export { create, update };
+}
+declare const create: (attrs: Partial<IDelegateState>, context: StateContextInput) => IDelegateState;
+declare const update: (state: IDelegateState, attrs: Partial<IDelegateState>, context: StateContextInput) => IDelegateState;
+//#endregion
+export { create, delegation_d_exports, update };

package/esm/states/delegation.mjs

@@ -0,0 +1,42 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { nullify } from "../util.mjs";
+import { toAddress } from "@ocap/util";
+import pick from "lodash/pick.js";
+
+//#region src/states/delegation.ts
+var delegation_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	update: () => update
+});
+const create = (attrs, context) => {
+	const delegation = {
+		context: create$1(context),
+		...pick(attrs, [
+			"address",
+			"to",
+			"from",
+			"ops",
+			"data"
+		])
+	};
+	if (!delegation.data) delegation.data = null;
+	delegation.address = toAddress(delegation.address);
+	delegation.ops = nullify(delegation.ops);
+	return delegation;
+};
+const update = (state, attrs, context) => {
+	const delegation = {
+		...state,
+		...pick(attrs, ["ops", "data"]),
+		context: update$1(state.context, context)
+	};
+	if (!delegation.data) delegation.data = null;
+	if (!state.to && attrs.to) delegation.to = toAddress(attrs.to);
+	if (!state.from && attrs.from) delegation.from = toAddress(attrs.from);
+	delegation.ops = nullify(delegation.ops);
+	return delegation;
+};
+
+//#endregion
+export { create, delegation_exports, update };

package/esm/states/evidence.d.mts

@@ -0,0 +1,12 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { IEvidenceState } from "@ocap/types";
+
+//#region src/states/evidence.d.ts
+declare namespace evidence_d_exports {
+  export { create, schema, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IEvidenceState>, context: StateContextInput) => IEvidenceState;
+declare const validate: (state: IEvidenceState) => IEvidenceState;
+//#endregion
+export { create, evidence_d_exports, schema, validate };

package/esm/states/evidence.mjs

@@ -0,0 +1,35 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1 } from "../contexts/state.mjs";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import { Joi, patterns, schemas } from "@arcblock/validator";
+
+//#region src/states/evidence.ts
+var evidence_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	schema: () => schema,
+	validate: () => validate
+});
+const schema = Joi.object({
+	hash: Joi.string().regex(patterns.txHash).required(),
+	context: schemas.context,
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	return validate({
+		context: create$1(context),
+		...pick(attrs, ["hash", "data"])
+	});
+};
+const validate = (state) => {
+	const { value, error } = schema.validate(state);
+	if (error) throw new CustomError("INVALID_EVIDENCE", `Invalid evidence state: ${error.details.map((x) => x.message).join(", ")}`);
+	if (!value.data) value.data = null;
+	return value;
+};
+
+//#endregion
+export { create, evidence_exports, schema, validate };

package/esm/states/factory.d.mts

@@ -0,0 +1,12 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { IAssetFactoryState } from "@ocap/types";
+
+//#region src/states/factory.d.ts
+declare namespace factory_d_exports {
+  export { create, update, validate };
+}
+declare const create: (attrs: Partial<IAssetFactoryState>, context: StateContextInput) => IAssetFactoryState;
+declare const update: (state: IAssetFactoryState, attrs: Partial<IAssetFactoryState>, context: StateContextInput) => IAssetFactoryState;
+declare const validate: (state: IAssetFactoryState) => IAssetFactoryState;
+//#endregion
+export { create, factory_d_exports, update, validate };