import { O as __exportAll, S as datetime, _ as string, b as url, d as email, h as object, m as number } from "./dist-fA4EItr0.mjs";
import { t as require_graphql } from "./graphql-DskHmkMe.mjs";
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/Amount.js
var Amount_exports = /* @__PURE__ */ __exportAll({
	config: () => config$16,
	scalar: () => scalar$16,
	schema: () => schema$15,
	stringSchema: () => stringSchema$16,
	type: () => type$16,
	typedef: () => typedef$16
});
var import_graphql = require_graphql();
const type$16 = "{ unit?: string, value?: number }";
const typedef$16 = "scalar Amount";
const schema$15 = object({
	unit: string().optional(),
	value: number().finite()
});
const stringSchema$16 = "z.object({ unit: z.string().optional(), value: z.number().finite() })";
const amountValidation = (value) => {
	if (typeof value !== "object" || !value) throw new import_graphql.GraphQLError(`Invalid Amount value: ${JSON.stringify(value)}`);
	const result = schema$15.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$16 = {
	name: "Amount",
	description: "A custom scalar that represents a currency amount with its currency type",
	serialize: amountValidation,
	parseValue: amountValidation,
	parseLiteral: (ast) => {
		if (ast.kind !== import_graphql.Kind.OBJECT) throw new import_graphql.GraphQLError("Value must be an object", { nodes: ast });
		const unitField = ast.fields.find((f) => f.name.value === "unit");
		const valueField = ast.fields.find((f) => f.name.value === "value");
		if (unitField && unitField.value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("unit must be a valid string value", { nodes: ast });
		if (!valueField || valueField.value.kind !== import_graphql.Kind.FLOAT) throw new import_graphql.GraphQLError("value must be a valid float value", { nodes: ast });
		return amountValidation({
			unit: unitField?.value?.value,
			value: parseFloat(valueField.value.value)
		});
	}
};
const scalar$16 = new import_graphql.GraphQLScalarType(config$16);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/AmountCrypto.js
var AmountCrypto_exports = /* @__PURE__ */ __exportAll({
	NUMERIC_VALUE_REGEX: () => NUMERIC_VALUE_REGEX$1,
	config: () => config$15,
	scalar: () => scalar$15,
	schema: () => schema$14,
	stringSchema: () => stringSchema$15,
	type: () => type$15,
	typedef: () => typedef$15
});
const NUMERIC_VALUE_REGEX$1 = /^\d+(\.\d+)?$/;
const type$15 = "{ unit: string, value: string }";
const typedef$15 = "scalar Amount_Crypto";
const schema$14 = object({
	unit: string(),
	value: string()
});
const stringSchema$15 = "z.object({ unit: z.string(), value: z.string() })";
const amountCryptoValidation = (value) => {
	if (typeof value !== "object" || !value) throw new import_graphql.GraphQLError(`Invalid Amount Crypto value: ${JSON.stringify(value)}`);
	const result = schema$14.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$15 = {
	name: "Amount_Crypto",
	description: "A custom scalar that represents a cryptocurrency amount with its currency type",
	serialize: amountCryptoValidation,
	parseValue: amountCryptoValidation,
	parseLiteral: (ast) => {
		if (ast.kind !== import_graphql.Kind.OBJECT) throw new import_graphql.GraphQLError("Value must be an object", { nodes: ast });
		const unitField = ast.fields.find((f) => f.name.value === "unit");
		const valueField = ast.fields.find((f) => f.name.value === "value");
		if (!unitField || unitField.value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("unit must be a valid string value", { nodes: ast });
		if (!valueField || valueField.value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("value must be a valid string value", { nodes: ast });
		if (!NUMERIC_VALUE_REGEX$1.test(valueField.value.value)) throw new import_graphql.GraphQLError("value must be a valid numeric string (e.g., \"123\" or \"123.45\")", { nodes: ast });
		return amountCryptoValidation({
			unit: unitField.value.value,
			value: valueField.value.value
		});
	}
};
const scalar$15 = new import_graphql.GraphQLScalarType(config$15);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/AmountCurrency.js
var AmountCurrency_exports = /* @__PURE__ */ __exportAll({
	NUMERIC_VALUE_REGEX: () => NUMERIC_VALUE_REGEX,
	config: () => config$14,
	scalar: () => scalar$14,
	schema: () => schema$13,
	stringSchema: () => stringSchema$14,
	type: () => type$14,
	typedef: () => typedef$14
});
const NUMERIC_VALUE_REGEX = /^\d+(\.\d+)?$/;
const type$14 = "{ unit: string, value: string }";
const typedef$14 = "scalar Amount_Currency";
const schema$13 = object({
	unit: string(),
	value: string()
});
const stringSchema$14 = "z.object({ unit: z.string(), value: z.string()})";
const amountCurrencyValidation = (value) => {
	if (typeof value !== "object" || !value) throw new import_graphql.GraphQLError(`Invalid Amount Currency value: ${JSON.stringify(value)}`);
	const result = schema$13.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$14 = {
	name: "Amount_Currency",
	description: "A custom scalar that represents a currency amount with its currency type",
	serialize: amountCurrencyValidation,
	parseValue: amountCurrencyValidation,
	parseLiteral: (ast) => {
		if (ast.kind !== import_graphql.Kind.OBJECT) throw new import_graphql.GraphQLError("Value must be an object", { nodes: ast });
		const unitField = ast.fields.find((f) => f.name.value === "unit");
		const valueField = ast.fields.find((f) => f.name.value === "value");
		if (!unitField || unitField.value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("unit must be a valid string value", { nodes: ast });
		if (!valueField || valueField.value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("value must be a valid string value", { nodes: ast });
		if (!NUMERIC_VALUE_REGEX.test(valueField.value.value)) throw new import_graphql.GraphQLError("value must be a valid numeric string (e.g., \"123\" or \"123.45\")", { nodes: ast });
		return amountCurrencyValidation({
			unit: unitField.value.value,
			value: valueField.value.value
		});
	}
};
const scalar$14 = new import_graphql.GraphQLScalarType(config$14);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/AmountFiat.js
var AmountFiat_exports = /* @__PURE__ */ __exportAll({
	config: () => config$13,
	scalar: () => scalar$13,
	schema: () => schema$12,
	stringSchema: () => stringSchema$13,
	type: () => type$13,
	typedef: () => typedef$13
});
const type$13 = "{ unit: string, value: number }";
const typedef$13 = "scalar Amount_Fiat";
const schema$12 = object({
	unit: string(),
	value: number().finite()
});
const stringSchema$13 = "z.object({ unit: z.string(), value: z.number().finite() })";
const amountFiatValidation = (value) => {
	if (typeof value !== "object" || !value) throw new import_graphql.GraphQLError(`Invalid Amount Fiat value: ${JSON.stringify(value)}`);
	const result = schema$12.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$13 = {
	name: "Amount_Fiat",
	description: "A custom scalar that represents a currency amount with its currency type",
	serialize: amountFiatValidation,
	parseValue: amountFiatValidation,
	parseLiteral: (ast) => {
		if (ast.kind !== import_graphql.Kind.OBJECT) throw new import_graphql.GraphQLError("Value must be an object", { nodes: ast });
		const unitField = ast.fields.find((f) => f.name.value === "unit");
		const valueField = ast.fields.find((f) => f.name.value === "value");
		if (!unitField || unitField.value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("unit must be a valid string value", { nodes: ast });
		if (!valueField || valueField.value.kind !== import_graphql.Kind.FLOAT) throw new import_graphql.GraphQLError("value must be a valid float value", { nodes: ast });
		return amountFiatValidation({
			unit: unitField.value.value,
			value: parseFloat(valueField.value.value)
		});
	}
};
const scalar$13 = new import_graphql.GraphQLScalarType(config$13);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/AmountMoney.js
var AmountMoney_exports = /* @__PURE__ */ __exportAll({
	config: () => config$12,
	scalar: () => scalar$12,
	schema: () => schema$11,
	stringSchema: () => stringSchema$12,
	type: () => type$12,
	typedef: () => typedef$12
});
const type$12 = "number";
const typedef$12 = "scalar Amount_Money";
const schema$11 = number();
const stringSchema$12 = "z.number()";
const amountMoneyValidation = (value) => {
	if (typeof value !== "number") throw new import_graphql.GraphQLError(`Value is not number: ${JSON.stringify(value)}`);
	if (!Number.isFinite(value)) throw new import_graphql.GraphQLError(`Value is not a finite number: ${value}`);
	const result = schema$11.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$12 = {
	name: "Amount_Money",
	description: "A custom scalar that represents a monetary amount in a currency",
	serialize: amountMoneyValidation,
	parseValue: amountMoneyValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.FLOAT) throw new import_graphql.GraphQLError("Value is not a float type", { nodes: value });
		return amountMoneyValidation(parseFloat(value.value));
	}
};
const scalar$12 = new import_graphql.GraphQLScalarType(config$12);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/AmountPercentage.js
var AmountPercentage_exports = /* @__PURE__ */ __exportAll({
	config: () => config$11,
	scalar: () => scalar$11,
	schema: () => schema$10,
	stringSchema: () => stringSchema$11,
	type: () => type$11,
	typedef: () => typedef$11
});
const type$11 = "number";
const typedef$11 = "scalar Amount_Percentage";
const schema$10 = number();
const stringSchema$11 = "z.number()";
const amountPercentageValidation = (value) => {
	if (typeof value !== "number") throw new import_graphql.GraphQLError(`Value is not number: ${JSON.stringify(value)}`);
	if (!Number.isFinite(value)) throw new import_graphql.GraphQLError(`Value is not a finite number: ${value}`);
	const result = schema$10.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$11 = {
	name: "Amount_Percentage",
	description: "",
	serialize: amountPercentageValidation,
	parseValue: amountPercentageValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.FLOAT) throw new import_graphql.GraphQLError("some error message", { nodes: value });
		return amountPercentageValidation(parseFloat(value.value));
	}
};
const scalar$11 = new import_graphql.GraphQLScalarType(config$11);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/AmountTokens.js
var AmountTokens_exports = /* @__PURE__ */ __exportAll({
	config: () => config$10,
	scalar: () => scalar$10,
	schema: () => schema$9,
	stringSchema: () => stringSchema$10,
	type: () => type$10,
	typedef: () => typedef$10
});
const type$10 = "number";
const typedef$10 = "scalar Amount_Tokens";
const schema$9 = number();
const stringSchema$10 = "z.number()";
const amountTokensValidation = (value) => {
	if (typeof value !== "number") throw new import_graphql.GraphQLError(`Value is not number: ${JSON.stringify(value)}`);
	if (!Number.isFinite(value)) throw new import_graphql.GraphQLError(`Value is not a finite number: ${value}`);
	const result = schema$9.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$10 = {
	name: "Amount_Tokens",
	description: "A custom scalar that represents an amount of tokens",
	serialize: amountTokensValidation,
	parseValue: amountTokensValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.FLOAT) throw new import_graphql.GraphQLError("some error message", { nodes: value });
		return amountTokensValidation(parseFloat(value.value));
	}
};
const scalar$10 = new import_graphql.GraphQLScalarType(config$10);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/Currency.js
var Currency_exports = /* @__PURE__ */ __exportAll({
	config: () => config$9,
	scalar: () => scalar$9,
	schema: () => schema$8,
	stringSchema: () => stringSchema$9,
	type: () => type$9,
	typedef: () => typedef$9
});
const type$9 = "string";
const typedef$9 = "scalar Currency";
const schema$8 = string();
const stringSchema$9 = "z.string()";
const currencyValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not string: ${JSON.stringify(value)}`);
	const result = schema$8.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$9 = {
	name: "Currency",
	description: "A custom scalar that represents a Currency Code string",
	serialize: currencyValidation,
	parseValue: currencyValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError(`Value is not a valid string: ${value.kind}`, { nodes: value });
		return currencyValidation(value.value);
	}
};
const scalar$9 = new import_graphql.GraphQLScalarType(config$9);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/Date.js
var Date_exports = /* @__PURE__ */ __exportAll({
	config: () => config$8,
	scalar: () => scalar$8,
	schema: () => schema$7,
	stringSchema: () => stringSchema$8,
	type: () => type$8,
	typedef: () => typedef$8
});
const type$8 = "string";
const typedef$8 = "scalar Date";
const schema$7 = datetime();
const stringSchema$8 = "z.iso.datetime()";
const datetimeValidation$1 = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not iso string: ${JSON.stringify(value)}`);
	const result = schema$7.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$8 = {
	name: "Date",
	description: "A custom scalar that represents a datetime in ISO 8601 format (Time: 00:00:00)",
	serialize: datetimeValidation$1,
	parseValue: datetimeValidation$1,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("Value is not an string", { nodes: value });
		return datetimeValidation$1(value.value);
	}
};
const scalar$8 = new import_graphql.GraphQLScalarType(config$8);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/DateTime.js
var DateTime_exports = /* @__PURE__ */ __exportAll({
	config: () => config$7,
	scalar: () => scalar$7,
	schema: () => schema$6,
	stringSchema: () => stringSchema$7,
	type: () => type$7,
	typedef: () => typedef$7
});
const type$7 = "string";
const typedef$7 = "scalar DateTime";
const schema$6 = datetime();
const stringSchema$7 = "z.iso.datetime()";
const datetimeValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not iso string: ${JSON.stringify(value)}`);
	const result = schema$6.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$7 = {
	name: "DateTime",
	description: "A custom scalar that represents a datetime in ISO 8601 format",
	serialize: datetimeValidation,
	parseValue: datetimeValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("Value is not an string", { nodes: value });
		return datetimeValidation(value.value);
	}
};
const scalar$7 = new import_graphql.GraphQLScalarType(config$7);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/EmailAddress.js
var EmailAddress_exports = /* @__PURE__ */ __exportAll({
	config: () => config$6,
	scalar: () => scalar$6,
	schema: () => schema$5,
	stringSchema: () => stringSchema$6,
	type: () => type$6,
	typedef: () => typedef$6
});
const type$6 = "string";
const typedef$6 = "scalar EmailAddress";
const schema$5 = email();
const stringSchema$6 = "z.email()";
const emailValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not string: ${JSON.stringify(value)}`);
	const result = schema$5.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$6 = {
	name: "EmailAddress",
	description: "A field whose value conforms to the standard internet email address format as specified in RFC822: https://www.w3.org/Protocols/rfc822/.",
	serialize: emailValidation,
	parseValue: emailValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError(`Can only validate strings as email addresses but got a: ${value.kind}`, { nodes: value });
		return emailValidation(value.value);
	}
};
const scalar$6 = new import_graphql.GraphQLScalarType(config$6);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/EthereumAddress.js
var EthereumAddress_exports = /* @__PURE__ */ __exportAll({
	config: () => config$5,
	scalar: () => scalar$5,
	schema: () => schema$4,
	stringSchema: () => stringSchema$5,
	type: () => type$5,
	typedef: () => typedef$5
});
const type$5 = "string";
const typedef$5 = "scalar EthereumAddress";
const schema$4 = string().regex(/^0x[a-fA-F0-9]{40}$/, { message: "Invalid Ethereum address format" });
const stringSchema$5 = "z.string().regex(/^0x[a-fA-F0-9]{40}$/, { message: 'Invalid Ethereum address format' })";
const addressValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not string: ${JSON.stringify(value)}`);
	const result = schema$4.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$5 = {
	name: "EthereumAddress",
	description: "A custom scalar representing an Ethereum address, validated as a 42-character hexadecimal string prefixed with \"0x\"",
	serialize: addressValidation,
	parseValue: addressValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("some error message", { nodes: value });
		return addressValidation(value.value);
	}
};
const scalar$5 = new import_graphql.GraphQLScalarType(config$5);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/OID.js
var OID_exports = /* @__PURE__ */ __exportAll({
	config: () => config$4,
	scalar: () => scalar$4,
	schema: () => schema$3,
	stringSchema: () => stringSchema$4,
	type: () => type$4,
	typedef: () => typedef$4
});
const type$4 = "string";
const typedef$4 = "scalar OID";
const schema$3 = string();
const stringSchema$4 = "z.string()";
const oIdValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not string: ${JSON.stringify(value)}`);
	const result = schema$3.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$4 = {
	name: "OID",
	description: "A custom scalar that represents a OID string",
	serialize: oIdValidation,
	parseValue: oIdValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError(`Value is not a valid string: ${value.kind}`, { nodes: value });
		return oIdValidation(value.value);
	}
};
const scalar$4 = new import_graphql.GraphQLScalarType(config$4);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/OLabel.js
var OLabel_exports = /* @__PURE__ */ __exportAll({
	config: () => config$3,
	scalar: () => scalar$3,
	schema: () => schema$2,
	stringSchema: () => stringSchema$3,
	type: () => type$3,
	typedef: () => typedef$3
});
const type$3 = "string";
const typedef$3 = "scalar OLabel";
const schema$2 = string();
const stringSchema$3 = "z.string()";
const oLabelValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not string: ${JSON.stringify(value)}`);
	const result = schema$2.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$3 = {
	name: "OLabel",
	description: "A custom scalar that represents a OLabel string",
	serialize: oLabelValidation,
	parseValue: oLabelValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError(`Value is not a valid string: ${value.kind}`, { nodes: value });
		return oLabelValidation(value.value);
	}
};
const scalar$3 = new import_graphql.GraphQLScalarType(config$3);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/PHID.js
var PHID_exports = /* @__PURE__ */ __exportAll({
	config: () => config$2,
	scalar: () => scalar$2,
	schema: () => schema$1,
	stringSchema: () => stringSchema$2,
	type: () => type$2,
	typedef: () => typedef$2
});
const type$2 = "string";
const typedef$2 = "scalar PHID";
const schema$1 = string();
const stringSchema$2 = "z.string()";
const phidlValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not string: ${JSON.stringify(value)}`);
	const result = schema$1.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$2 = {
	name: "PHID",
	description: "A custom scalar that represents a PowerhouseID string",
	serialize: phidlValidation,
	parseValue: phidlValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError(`Value is not a valid string: ${value.kind}`, { nodes: value });
		return phidlValidation(value.value);
	}
};
const scalar$2 = new import_graphql.GraphQLScalarType(config$2);
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/URL.js
var URL_exports = /* @__PURE__ */ __exportAll({
	config: () => config$1,
	scalar: () => scalar$1,
	schema: () => schema,
	stringSchema: () => stringSchema$1,
	type: () => type$1,
	typedef: () => typedef$1
});
const type$1 = "string";
const typedef$1 = "scalar URL";
const schema = url();
const stringSchema$1 = "z.url()";
const urlValidation = (value) => {
	if (typeof value !== "string") throw new import_graphql.GraphQLError(`Value is not iso string: ${JSON.stringify(value)}`);
	const result = schema.safeParse(value);
	if (result.success) return result.data;
	throw new import_graphql.GraphQLError(result.error.message);
};
const config$1 = {
	name: "URL",
	description: "A custom scalar that represents a URL string",
	serialize: urlValidation,
	parseValue: urlValidation,
	parseLiteral: (value) => {
		if (value.kind !== import_graphql.Kind.STRING) throw new import_graphql.GraphQLError("Value is not an string", { nodes: value });
		return urlValidation(value.value);
	}
};
const scalar$1 = new import_graphql.GraphQLScalarType(config$1);
//#endregion
//#region ../../node_modules/.pnpm/graphql-upload@17.0.0_@types+express@4.17.25_graphql@16.12.0/node_modules/graphql-upload/Upload.mjs
/**
* @import GraphQLUpload from "./GraphQLUpload.mjs"
* @import processRequest, { FileUpload } from "./processRequest.mjs"
*/
/**
* A file expected to be uploaded as it was declared in the `map` field of a
* [GraphQL multipart request](https://github.com/jaydenseric/graphql-multipart-request-spec).
* The {@linkcode processRequest} function places references to an instance of
* this class wherever the file is expected in the GraphQL operation. The scalar
* {@linkcode GraphQLUpload} derives it’s value from {@linkcode Upload.promise}.
*/
var Upload = class {
	constructor() {
		/**
		* Promise that resolves file upload details. This should only be utilized
		* by {@linkcode GraphQLUpload}.
		* @type {Promise<FileUpload>}
		*/
		this.promise = new Promise((resolve, reject) => {
			/**
			* Resolves the upload promise with the file upload details. This should
			* only be utilized by {@linkcode processRequest}.
			* @param {FileUpload} file File upload details.
			*/
			this.resolve = (file) => {
				/**
				* The file upload details, available when the
				* {@linkcode Upload.promise} resolves. This should only be utilized by
				* {@linkcode processRequest}.
				* @type {FileUpload | undefined}
				*/
				this.file = file;
				resolve(file);
			};
			/**
			* Rejects the upload promise with an error. This should only be
			* utilized by {@linkcode processRequest}.
			* @param {Error} error Error instance.
			*/
			this.reject = reject;
		});
		this.promise.catch(() => {});
	}
};
//#endregion
//#region ../../node_modules/.pnpm/graphql-upload@17.0.0_@types+express@4.17.25_graphql@16.12.0/node_modules/graphql-upload/GraphQLUpload.mjs
/** @typedef {import("./processRequest.mjs").FileUpload} FileUpload */
/**
* A GraphQL scalar `Upload` that can be used in a
* [`GraphQLSchema`](https://graphql.org/graphql-js/type/#graphqlschema). It’s
* value in resolvers is a promise that resolves
* {@link FileUpload file upload details} for processing and storage.
* @example
* A schema built using the function
* [`makeExecutableSchema`](https://www.graphql-tools.com/docs/api/modules/schema_src#makeexecutableschema)
* from [`@graphql-tools/schema`](https://npm.im/@graphql-tools/schema):
*
* ```js
* import { makeExecutableSchema } from "@graphql-tools/schema/makeExecutableSchema";
* import GraphQLUpload from "graphql-upload/GraphQLUpload.mjs";
*
* const schema = makeExecutableSchema({
*   typeDefs: `
*     scalar Upload
*   `,
*   resolvers: {
*     Upload: GraphQLUpload,
*   },
* });
* ```
* @example
* A manually constructed schema with an image upload mutation:
*
* ```js
* import { GraphQLBoolean, GraphQLObjectType, GraphQLSchema } from "graphql";
* import GraphQLUpload from "graphql-upload/GraphQLUpload.mjs";
*
* const schema = new GraphQLSchema({
*   mutation: new GraphQLObjectType({
*     name: "Mutation",
*     fields: {
*       uploadImage: {
*         description: "Uploads an image.",
*         type: GraphQLBoolean,
*         args: {
*           image: {
*             description: "Image file.",
*             type: GraphQLUpload,
*           },
*         },
*         async resolve(parent, { image }) {
*           const { filename, mimetype, createReadStream } = await image;
*           const stream = createReadStream();
*           // Promisify the stream and store the file, then…
*           return true;
*         },
*       },
*     },
*   }),
* });
* ```
* @example
* In a [TypeScript](https://typescriptlang.org) module, how to import the type
* for the {@link FileUpload file upload details} that the
* {@linkcode GraphQLUpload} scalar resolver value promise resolves:
*
* ```ts
* import type { FileUpload } from "graphql-upload/processRequest.mjs";
* ```
*/
const GraphQLUpload = new import_graphql.GraphQLScalarType({
	name: "Upload",
	description: "The `Upload` scalar type represents a file upload.",
	parseValue(value) {
		if (value instanceof Upload) return value.promise;
		throw new import_graphql.GraphQLError("Upload value invalid.");
	},
	parseLiteral(node) {
		throw new import_graphql.GraphQLError("Upload literal unsupported.", { nodes: node });
	},
	serialize() {
		throw new import_graphql.GraphQLError("Upload serialization unsupported.");
	}
});
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/File.js
var File_exports = /* @__PURE__ */ __exportAll({
	config: () => config,
	scalar: () => scalar,
	stringSchema: () => stringSchema,
	type: () => type,
	typedef: () => typedef
});
const type = "File";
const typedef = "scalar Upload";
const config = {
	name: "Upload",
	description: "A custom scalar that represents a file upload"
};
const stringSchema = "z.any()";
const scalar = GraphQLUpload;
//#endregion
//#region ../../node_modules/.pnpm/@powerhousedao+document-engineering@1.40.5_@types+express@4.17.25_@types+react-dom@19.2_75e28b6ec666f63b132a491ff3a6fdf7/node_modules/@powerhousedao/document-engineering/dist/src/scalars/graphql/scalars.js
const customScalars = {
	Amount: Amount_exports,
	AmountCrypto: AmountCrypto_exports,
	AmountCurrency: AmountCurrency_exports,
	AmountFiat: AmountFiat_exports,
	AmountMoney: AmountMoney_exports,
	AmountPercentage: AmountPercentage_exports,
	AmountTokens: AmountTokens_exports,
	Currency: Currency_exports,
	DateScalar: Date_exports,
	DateTime: DateTime_exports,
	EmailAddress: EmailAddress_exports,
	EthereumAddress: EthereumAddress_exports,
	File: File_exports,
	OID: OID_exports,
	OLabel: OLabel_exports,
	PHID: PHID_exports,
	URLScalar: URL_exports
};
const typeDefs = [
	typedef$10,
	typedef$5,
	typedef$11,
	typedef$6,
	typedef$8,
	typedef$7,
	typedef$1,
	typedef$12,
	typedef$3,
	typedef$9,
	typedef$2,
	typedef$4,
	typedef$13,
	typedef$14,
	typedef$15,
	typedef$16,
	typedef
];
config$10.name, config$5.name, config$6.name, config$11.name, config$8.name, config$7.name, config$1.name, config$12.name, config$3.name, config$9.name, config$2.name, config$4.name, config$13.name, config$14.name, config$15.name, config$16.name, config.name;
config$10.name, config$5.name, config$6.name, config$11.name, config$8.name, config$7.name, config$1.name, config$12.name, config$3.name, config$9.name, config$2.name, config$4.name, config$13.name, config$14.name, config$15.name, config$16.name, config.name;
//#endregion
//#region editors/document-model-editor/constants/documents.ts
const hiddenQueryTypeDefDoc = `type Query {
  _hidden: String
}
`;
const typeDefsDoc = typeDefs.join("\n");
const initialSchemaDoc = `${hiddenQueryTypeDefDoc}\n${typeDefsDoc}`;
const initialSchema = (0, import_graphql.buildSchema)(initialSchemaDoc);
const initialSchemaStr = (0, import_graphql.printSchema)(initialSchema);
const updateTimeout = 5e3;
//#endregion
export { customScalars as a, updateTimeout as i, initialSchemaStr as n, typeDefsDoc as r, hiddenQueryTypeDefDoc as t };

//# sourceMappingURL=documents-BFBPmyw1.mjs.map