import { r as __exportAll } from "./chunk-BSw8zbkd.mjs";
import { A as any, B as generateId, F as number, I as object, L as string, M as boolean, N as lazy, P as literal, a as BaseDocumentHeaderSchema, b as isDocumentAction, c as baseCreateDocument, f as createAction, g as createState, h as createReducer, j as array, l as baseLoadFromInput, o as BaseDocumentStateSchema, s as baseActions, u as baseSaveToFileHandle, v as defaultBaseState, z as datetime } from "./dist-RakiOObV.mjs";
//#region document-models/vault-config/v1/gen/schema/zod.ts
const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
const definedNonNullAnySchema = any().refine((v) => isDefinedNonNullAny(v));
function AddExtractionCategoryInputSchema() {
	return object({
		active: boolean(),
		description: string(),
		id: string(),
		name: string()
	});
}
function DimensionConfigSchema() {
	return object({
		__typename: literal("DimensionConfig").optional(),
		automation: lazy(() => DimensionPositionSchema()),
		granularity: lazy(() => DimensionPositionSchema()),
		linking: lazy(() => DimensionPositionSchema()),
		maintenance: lazy(() => DimensionPositionSchema()),
		navigation: lazy(() => DimensionPositionSchema()),
		organization: lazy(() => DimensionPositionSchema()),
		processing: lazy(() => DimensionPositionSchema()),
		schema: lazy(() => DimensionPositionSchema())
	});
}
function DimensionPositionSchema() {
	return object({
		__typename: literal("DimensionPosition").optional(),
		confidence: number(),
		rationale: string().nullish(),
		value: number()
	});
}
function ExtractionCategorySchema() {
	return object({
		__typename: literal("ExtractionCategory").optional(),
		active: boolean(),
		description: string(),
		id: string(),
		name: string()
	});
}
function InitializeConfigInputSchema() {
	return object({
		domain: string(),
		name: string(),
		updatedAt: datetime()
	});
}
function MaintenanceConfigSchema() {
	return object({
		__typename: literal("MaintenanceConfig").optional(),
		danglingThreshold: number(),
		inboxPressure: number(),
		mocOversize: number(),
		observationAccumulation: number(),
		orphanThreshold: number(),
		staleNoteDays: number(),
		tensionAccumulation: number()
	});
}
function MocSchemaConfigSchema() {
	return object({
		__typename: literal("MocSchemaConfig").optional(),
		requiredFields: array(string()),
		tierValues: array(string())
	});
}
function NoteSchemaConfigSchema() {
	return object({
		__typename: literal("NoteSchemaConfig").optional(),
		confidenceValues: array(string()),
		kindValues: array(string()),
		optionalFields: array(string()),
		requiredFields: array(string())
	});
}
function PipelineConfigSchema() {
	return object({
		__typename: literal("PipelineConfig").optional(),
		autoChain: boolean(),
		depth: string(),
		extractionSelectivity: number()
	});
}
function ToggleExtractionCategoryInputSchema() {
	return object({
		active: boolean(),
		id: string()
	});
}
function ToggleFeatureInputSchema() {
	return object({
		enabled: boolean(),
		feature: string()
	});
}
function UpdateDimensionInputSchema() {
	return object({
		confidence: number(),
		dimension: string(),
		rationale: string().nullish(),
		updatedAt: datetime(),
		value: number()
	});
}
function UpdateMaintenanceThresholdInputSchema() {
	return object({
		condition: string(),
		threshold: number(),
		updatedAt: datetime()
	});
}
function UpdatePipelineConfigInputSchema() {
	return object({
		autoChain: boolean().nullish(),
		depth: string().nullish(),
		extractionSelectivity: number().nullish(),
		updatedAt: datetime()
	});
}
function UpdateVocabularyInputSchema() {
	return object({
		key: string(),
		updatedAt: datetime(),
		value: string()
	});
}
function VaultConfigStateSchema() {
	return object({
		__typename: literal("VaultConfigState").optional(),
		dimensions: lazy(() => DimensionConfigSchema().nullish()),
		domain: string().nullish(),
		extractionCategories: array(lazy(() => ExtractionCategorySchema())),
		features: array(string()),
		maintenance: lazy(() => MaintenanceConfigSchema().nullish()),
		mocSchema: lazy(() => MocSchemaConfigSchema().nullish()),
		name: string().nullish(),
		noteSchema: lazy(() => NoteSchemaConfigSchema().nullish()),
		pipeline: lazy(() => PipelineConfigSchema().nullish()),
		updatedAt: datetime().nullish(),
		vocabulary: lazy(() => VocabularyMapSchema().nullish())
	});
}
function VocabularyMapSchema() {
	return object({
		__typename: literal("VocabularyMap").optional(),
		description: string(),
		inbox: string(),
		notes: string(),
		reduce: string(),
		reflect: string(),
		rethink: string(),
		reweave: string(),
		topicMap: string(),
		verify: string()
	});
}
//#endregion
//#region document-models/vault-config/v1/gen/config-management/creators.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
var creators_exports = /* @__PURE__ */ __exportAll({
	addExtractionCategory: () => addExtractionCategory,
	initializeConfig: () => initializeConfig,
	toggleExtractionCategory: () => toggleExtractionCategory,
	toggleFeature: () => toggleFeature,
	updateDimension: () => updateDimension,
	updateMaintenanceThreshold: () => updateMaintenanceThreshold,
	updatePipelineConfig: () => updatePipelineConfig,
	updateVocabulary: () => updateVocabulary
});
const initializeConfig = (input) => createAction("INITIALIZE_CONFIG", { ...input }, void 0, InitializeConfigInputSchema, "global");
const updateDimension = (input) => createAction("UPDATE_DIMENSION", { ...input }, void 0, UpdateDimensionInputSchema, "global");
const updateVocabulary = (input) => createAction("UPDATE_VOCABULARY", { ...input }, void 0, UpdateVocabularyInputSchema, "global");
const updatePipelineConfig = (input) => createAction("UPDATE_PIPELINE_CONFIG", { ...input }, void 0, UpdatePipelineConfigInputSchema, "global");
const updateMaintenanceThreshold = (input) => createAction("UPDATE_MAINTENANCE_THRESHOLD", { ...input }, void 0, UpdateMaintenanceThresholdInputSchema, "global");
const addExtractionCategory = (input) => createAction("ADD_EXTRACTION_CATEGORY", { ...input }, void 0, AddExtractionCategoryInputSchema, "global");
const toggleExtractionCategory = (input) => createAction("TOGGLE_EXTRACTION_CATEGORY", { ...input }, void 0, ToggleExtractionCategoryInputSchema, "global");
const toggleFeature = (input) => createAction("TOGGLE_FEATURE", { ...input }, void 0, ToggleFeatureInputSchema, "global");
//#endregion
//#region document-models/vault-config/v1/actions.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
/** Actions for the VaultConfig document model */
const actions = {
	...baseActions,
	...creators_exports
};
//#endregion
//#region document-models/vault-config/v1/gen/document-model.ts
const documentModel = {
	author: {
		name: "BAI",
		website: "https://bai.powerhouse.io/"
	},
	description: "Live vault configuration — singleton document controlling the 8-dimension parameter space, vocabulary mapping, pipeline settings, and maintenance thresholds",
	extension: "",
	id: "bai/vault-config",
	name: "VaultConfig",
	specifications: [{
		changeLog: [],
		modules: [{
			description: "Vault configuration lifecycle",
			id: "config-management",
			name: "config-management",
			operations: [
				{
					description: "Initialize vault configuration with name and domain",
					errors: [],
					examples: [],
					id: "initialize-config",
					name: "INITIALIZE_CONFIG",
					reducer: "state.name = action.input.name;\nstate.domain = action.input.domain;\nstate.updatedAt = action.input.updatedAt;",
					schema: "input InitializeConfigInput {\n    name: String!\n    domain: String!\n    updatedAt: DateTime!\n}",
					template: "Initialize vault configuration with name and domain",
					scope: "global"
				},
				{
					description: "Update a dimension position",
					errors: [],
					examples: [],
					id: "update-dimension",
					name: "UPDATE_DIMENSION",
					reducer: "if (!state.dimensions) state.dimensions = {\n    granularity: { value: 3, confidence: 0.5, rationale: null },\n    organization: { value: 3, confidence: 0.5, rationale: null },\n    linking: { value: 3, confidence: 0.5, rationale: null },\n    processing: { value: 3, confidence: 0.5, rationale: null },\n    navigation: { value: 3, confidence: 0.5, rationale: null },\n    maintenance: { value: 3, confidence: 0.5, rationale: null },\n    schema: { value: 3, confidence: 0.5, rationale: null },\n    automation: { value: 3, confidence: 0.5, rationale: null },\n};\nconst dim = action.input.dimension;\nif (dim in state.dimensions) {\n    (state.dimensions as any)[dim] = {\n        value: action.input.value,\n        confidence: action.input.confidence,\n        rationale: action.input.rationale || null,\n    };\n}\nstate.updatedAt = action.input.updatedAt;",
					schema: "input UpdateDimensionInput {\n    dimension: String!\n    value: Int!\n    confidence: Float!\n    rationale: String\n    updatedAt: DateTime!\n}",
					template: "Update a dimension position",
					scope: "global"
				},
				{
					description: "Update a vocabulary term",
					errors: [],
					examples: [],
					id: "update-vocabulary",
					name: "UPDATE_VOCABULARY",
					reducer: "if (!state.vocabulary) state.vocabulary = {\n    notes: \"notes\", inbox: \"inbox\", reduce: \"reduce\", reflect: \"reflect\",\n    reweave: \"reweave\", verify: \"verify\", rethink: \"rethink\",\n    topicMap: \"topic map\", description: \"description\",\n};\nif (action.input.key in state.vocabulary) {\n    (state.vocabulary as any)[action.input.key] = action.input.value;\n}\nstate.updatedAt = action.input.updatedAt;",
					schema: "input UpdateVocabularyInput {\n    key: String!\n    value: String!\n    updatedAt: DateTime!\n}",
					template: "Update a vocabulary term",
					scope: "global"
				},
				{
					description: "Update pipeline settings",
					errors: [],
					examples: [],
					id: "update-pipeline-config",
					name: "UPDATE_PIPELINE_CONFIG",
					reducer: "if (!state.pipeline) state.pipeline = { depth: \"standard\", autoChain: false, extractionSelectivity: 0.1 };\nif (action.input.depth) state.pipeline.depth = action.input.depth;\nif (action.input.autoChain !== undefined && action.input.autoChain !== null) state.pipeline.autoChain = action.input.autoChain;\nif (action.input.extractionSelectivity !== undefined && action.input.extractionSelectivity !== null) state.pipeline.extractionSelectivity = action.input.extractionSelectivity;\nstate.updatedAt = action.input.updatedAt;",
					schema: "input UpdatePipelineConfigInput {\n    depth: String\n    autoChain: Boolean\n    extractionSelectivity: Float\n    updatedAt: DateTime!\n}",
					template: "Update pipeline settings",
					scope: "global"
				},
				{
					description: "Update a maintenance threshold",
					errors: [],
					examples: [],
					id: "update-maintenance-threshold",
					name: "UPDATE_MAINTENANCE_THRESHOLD",
					reducer: "if (!state.maintenance) state.maintenance = {\n    orphanThreshold: 1, danglingThreshold: 1, inboxPressure: 5,\n    observationAccumulation: 10, tensionAccumulation: 5, mocOversize: 40, staleNoteDays: 30,\n};\nif (action.input.condition in state.maintenance) {\n    (state.maintenance as any)[action.input.condition] = action.input.threshold;\n}\nstate.updatedAt = action.input.updatedAt;",
					schema: "input UpdateMaintenanceThresholdInput {\n    condition: String!\n    threshold: Int!\n    updatedAt: DateTime!\n}",
					template: "Update a maintenance threshold",
					scope: "global"
				},
				{
					description: "Add an extraction category",
					errors: [],
					examples: [],
					id: "add-extraction-category",
					name: "ADD_EXTRACTION_CATEGORY",
					reducer: "state.extractionCategories.push({\n    id: action.input.id,\n    name: action.input.name,\n    description: action.input.description,\n    active: action.input.active,\n});",
					schema: "input AddExtractionCategoryInput {\n    id: OID!\n    name: String!\n    description: String!\n    active: Boolean!\n}",
					template: "Add an extraction category",
					scope: "global"
				},
				{
					description: "Enable/disable an extraction category",
					errors: [],
					examples: [],
					id: "toggle-extraction-category",
					name: "TOGGLE_EXTRACTION_CATEGORY",
					reducer: "const cat = state.extractionCategories.find(c => c.id === action.input.id);\nif (cat) cat.active = action.input.active;",
					schema: "input ToggleExtractionCategoryInput {\n    id: OID!\n    active: Boolean!\n}",
					template: "Enable/disable an extraction category",
					scope: "global"
				},
				{
					description: "Enable/disable a feature block",
					errors: [],
					examples: [],
					id: "toggle-feature",
					name: "TOGGLE_FEATURE",
					reducer: "if (action.input.enabled && !state.features.includes(action.input.feature)) {\n    state.features.push(action.input.feature);\n} else if (!action.input.enabled) {\n    state.features = state.features.filter(f => f !== action.input.feature);\n}",
					schema: "input ToggleFeatureInput {\n    feature: String!\n    enabled: Boolean!\n}",
					template: "Enable/disable a feature block",
					scope: "global"
				}
			]
		}],
		state: {
			global: {
				examples: [],
				initialValue: "{\n    \"name\": null,\n    \"domain\": null,\n    \"dimensions\": null,\n    \"vocabulary\": null,\n    \"features\": [],\n    \"pipeline\": null,\n    \"maintenance\": null,\n    \"extractionCategories\": [],\n    \"noteSchema\": null,\n    \"mocSchema\": null,\n    \"updatedAt\": null\n}",
				schema: "type DimensionPosition {\n    value: Int!\n    confidence: Float!\n    rationale: String\n}\n\ntype DimensionConfig {\n    granularity: DimensionPosition!\n    organization: DimensionPosition!\n    linking: DimensionPosition!\n    processing: DimensionPosition!\n    navigation: DimensionPosition!\n    maintenance: DimensionPosition!\n    schema: DimensionPosition!\n    automation: DimensionPosition!\n}\n\ntype VocabularyMap {\n    notes: String!\n    inbox: String!\n    reduce: String!\n    reflect: String!\n    reweave: String!\n    verify: String!\n    rethink: String!\n    topicMap: String!\n    description: String!\n}\n\ntype PipelineConfig {\n    depth: String!\n    autoChain: Boolean!\n    extractionSelectivity: Float!\n}\n\ntype MaintenanceConfig {\n    orphanThreshold: Int!\n    danglingThreshold: Int!\n    inboxPressure: Int!\n    observationAccumulation: Int!\n    tensionAccumulation: Int!\n    mocOversize: Int!\n    staleNoteDays: Int!\n}\n\ntype ExtractionCategory {\n    id: OID!\n    name: String!\n    description: String!\n    active: Boolean!\n}\n\ntype NoteSchemaConfig {\n    requiredFields: [String!]!\n    optionalFields: [String!]!\n    kindValues: [String!]!\n    confidenceValues: [String!]!\n}\n\ntype MocSchemaConfig {\n    requiredFields: [String!]!\n    tierValues: [String!]!\n}\n\ntype VaultConfigState {\n    name: String\n    domain: String\n    dimensions: DimensionConfig\n    vocabulary: VocabularyMap\n    features: [String!]!\n    pipeline: PipelineConfig\n    maintenance: MaintenanceConfig\n    extractionCategories: [ExtractionCategory!]!\n    noteSchema: NoteSchemaConfig\n    mocSchema: MocSchemaConfig\n    updatedAt: DateTime\n}"
			},
			local: {
				examples: [],
				initialValue: "",
				schema: ""
			}
		},
		version: 1
	}]
};
//#endregion
//#region document-models/vault-config/v1/src/reducers/config-management.ts
const vaultConfigConfigManagementOperations = {
	initializeConfigOperation(state, action) {
		state.name = action.input.name;
		state.domain = action.input.domain;
		state.updatedAt = action.input.updatedAt;
	},
	updateDimensionOperation(state, action) {
		if (!state.dimensions) state.dimensions = {
			granularity: {
				value: 3,
				confidence: .5,
				rationale: null
			},
			organization: {
				value: 3,
				confidence: .5,
				rationale: null
			},
			linking: {
				value: 3,
				confidence: .5,
				rationale: null
			},
			processing: {
				value: 3,
				confidence: .5,
				rationale: null
			},
			navigation: {
				value: 3,
				confidence: .5,
				rationale: null
			},
			maintenance: {
				value: 3,
				confidence: .5,
				rationale: null
			},
			schema: {
				value: 3,
				confidence: .5,
				rationale: null
			},
			automation: {
				value: 3,
				confidence: .5,
				rationale: null
			}
		};
		const dim = action.input.dimension;
		if (dim in state.dimensions) state.dimensions[dim] = {
			value: action.input.value,
			confidence: action.input.confidence,
			rationale: action.input.rationale || null
		};
		state.updatedAt = action.input.updatedAt;
	},
	updateVocabularyOperation(state, action) {
		if (!state.vocabulary) state.vocabulary = {
			notes: "notes",
			inbox: "inbox",
			reduce: "reduce",
			reflect: "reflect",
			reweave: "reweave",
			verify: "verify",
			rethink: "rethink",
			topicMap: "topic map",
			description: "description"
		};
		if (action.input.key in state.vocabulary) state.vocabulary[action.input.key] = action.input.value;
		state.updatedAt = action.input.updatedAt;
	},
	updatePipelineConfigOperation(state, action) {
		if (!state.pipeline) state.pipeline = {
			depth: "standard",
			autoChain: false,
			extractionSelectivity: .1
		};
		if (action.input.depth) state.pipeline.depth = action.input.depth;
		if (action.input.autoChain !== void 0 && action.input.autoChain !== null) state.pipeline.autoChain = action.input.autoChain;
		if (action.input.extractionSelectivity !== void 0 && action.input.extractionSelectivity !== null) state.pipeline.extractionSelectivity = action.input.extractionSelectivity;
		state.updatedAt = action.input.updatedAt;
	},
	updateMaintenanceThresholdOperation(state, action) {
		if (!state.maintenance) state.maintenance = {
			orphanThreshold: 1,
			danglingThreshold: 1,
			inboxPressure: 5,
			observationAccumulation: 10,
			tensionAccumulation: 5,
			mocOversize: 40,
			staleNoteDays: 30
		};
		if (action.input.condition in state.maintenance) state.maintenance[action.input.condition] = action.input.threshold;
		state.updatedAt = action.input.updatedAt;
	},
	addExtractionCategoryOperation(state, action) {
		state.extractionCategories.push({
			id: action.input.id,
			name: action.input.name,
			description: action.input.description,
			active: action.input.active
		});
	},
	toggleExtractionCategoryOperation(state, action) {
		const cat = state.extractionCategories.find((c) => c.id === action.input.id);
		if (cat) cat.active = action.input.active;
	},
	toggleFeatureOperation(state, action) {
		if (action.input.enabled && !state.features.includes(action.input.feature)) state.features.push(action.input.feature);
		else if (!action.input.enabled) state.features = state.features.filter((f) => f !== action.input.feature);
	}
};
//#endregion
//#region document-models/vault-config/v1/gen/reducer.ts
const stateReducer = (state, action, dispatch) => {
	if (isDocumentAction(action)) return state;
	switch (action.type) {
		case "INITIALIZE_CONFIG":
			InitializeConfigInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.initializeConfigOperation(state[action.scope], action, dispatch);
			break;
		case "UPDATE_DIMENSION":
			UpdateDimensionInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.updateDimensionOperation(state[action.scope], action, dispatch);
			break;
		case "UPDATE_VOCABULARY":
			UpdateVocabularyInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.updateVocabularyOperation(state[action.scope], action, dispatch);
			break;
		case "UPDATE_PIPELINE_CONFIG":
			UpdatePipelineConfigInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.updatePipelineConfigOperation(state[action.scope], action, dispatch);
			break;
		case "UPDATE_MAINTENANCE_THRESHOLD":
			UpdateMaintenanceThresholdInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.updateMaintenanceThresholdOperation(state[action.scope], action, dispatch);
			break;
		case "ADD_EXTRACTION_CATEGORY":
			AddExtractionCategoryInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.addExtractionCategoryOperation(state[action.scope], action, dispatch);
			break;
		case "TOGGLE_EXTRACTION_CATEGORY":
			ToggleExtractionCategoryInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.toggleExtractionCategoryOperation(state[action.scope], action, dispatch);
			break;
		case "TOGGLE_FEATURE":
			ToggleFeatureInputSchema().parse(action.input);
			vaultConfigConfigManagementOperations.toggleFeatureOperation(state[action.scope], action, dispatch);
			break;
		default: return state;
	}
};
const reducer = createReducer(stateReducer);
//#endregion
//#region document-models/vault-config/v1/gen/document-type.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
const vaultConfigDocumentType = "bai/vault-config";
//#endregion
//#region document-models/vault-config/v1/gen/document-schema.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
/** Schema for validating the header object of a VaultConfig document */
const VaultConfigDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({ documentType: literal(vaultConfigDocumentType) });
/** Schema for validating the state object of a VaultConfig document */
const VaultConfigPHStateSchema = BaseDocumentStateSchema.extend({ global: VaultConfigStateSchema() });
const VaultConfigDocumentSchema = object({
	header: VaultConfigDocumentHeaderSchema,
	state: VaultConfigPHStateSchema,
	initialState: VaultConfigPHStateSchema
});
/** Simple helper function to check if a state object is a VaultConfig document state object */
function isVaultConfigState(state) {
	return VaultConfigPHStateSchema.safeParse(state).success;
}
/** Simple helper function to assert that a document state object is a VaultConfig document state object */
function assertIsVaultConfigState(state) {
	VaultConfigPHStateSchema.parse(state);
}
/** Simple helper function to check if a document is a VaultConfig document */
function isVaultConfigDocument(document) {
	return VaultConfigDocumentSchema.safeParse(document).success;
}
/** Simple helper function to assert that a document is a VaultConfig document */
function assertIsVaultConfigDocument(document) {
	VaultConfigDocumentSchema.parse(document);
}
//#endregion
//#region document-models/vault-config/v1/gen/utils.ts
const initialGlobalState = {
	name: null,
	domain: null,
	dimensions: null,
	vocabulary: null,
	features: [],
	pipeline: null,
	maintenance: null,
	extractionCategories: [],
	noteSchema: null,
	mocSchema: null,
	updatedAt: null
};
const initialLocalState = {};
const utils$1 = {
	fileExtension: "",
	createState(state) {
		return {
			...defaultBaseState(),
			global: {
				...initialGlobalState,
				...state?.global
			},
			local: {
				...initialLocalState,
				...state?.local
			}
		};
	},
	createDocument(state) {
		const document = baseCreateDocument(utils$1.createState, state);
		document.header.documentType = vaultConfigDocumentType;
		document.header.id = generateId();
		return document;
	},
	saveToFileHandle(document, input) {
		return baseSaveToFileHandle(document, input);
	},
	loadFromInput(input) {
		return baseLoadFromInput(input, reducer);
	},
	isStateOfType(state) {
		return isVaultConfigState(state);
	},
	assertIsStateOfType(state) {
		return assertIsVaultConfigState(state);
	},
	isDocumentOfType(document) {
		return isVaultConfigDocument(document);
	},
	assertIsDocumentOfType(document) {
		return assertIsVaultConfigDocument(document);
	}
};
//#endregion
//#region document-models/vault-config/v1/src/utils.ts
var utils_exports = /* @__PURE__ */ __exportAll({});
//#endregion
//#region document-models/vault-config/v1/utils.ts
/** Utils for the VaultConfig document model */
const utils = {
	...utils$1,
	...utils_exports
};
//#endregion
//#region document-models/vault-config/v1/module.ts
/** Document model module for the VaultConfig document type */
const VaultConfig = {
	version: 1,
	reducer,
	actions,
	utils,
	documentModel: createState(defaultBaseState(), documentModel)
};
//#endregion
export { InitializeConfigInputSchema as A, UpdateVocabularyInputSchema as B, updateMaintenanceThreshold as C, DimensionConfigSchema as D, AddExtractionCategoryInputSchema as E, ToggleExtractionCategoryInputSchema as F, VocabularyMapSchema as H, ToggleFeatureInputSchema as I, UpdateDimensionInputSchema as L, MocSchemaConfigSchema as M, NoteSchemaConfigSchema as N, DimensionPositionSchema as O, PipelineConfigSchema as P, UpdateMaintenanceThresholdInputSchema as R, updateDimension as S, updateVocabulary as T, definedNonNullAnySchema as U, VaultConfigStateSchema as V, isDefinedNonNullAny as W, addExtractionCategory as _, utils$1 as a, toggleExtractionCategory as b, VaultConfigPHStateSchema as c, isVaultConfigDocument as d, isVaultConfigState as f, actions as g, documentModel as h, initialLocalState as i, MaintenanceConfigSchema as j, ExtractionCategorySchema as k, assertIsVaultConfigDocument as l, reducer as m, utils as n, VaultConfigDocumentHeaderSchema as o, vaultConfigDocumentType as p, initialGlobalState as r, VaultConfigDocumentSchema as s, VaultConfig as t, assertIsVaultConfigState as u, creators_exports as v, updatePipelineConfig as w, toggleFeature as x, initializeConfig as y, UpdatePipelineConfigInputSchema as z };

//# sourceMappingURL=module-CtH3vWTD.mjs.map