modify_metadata

Set properties of any metadata node, including managed-form roots, items, attributes, commands, and handlers. Parameters and examples: get_tool_guide('modify_metadata').

Parameters

Parameter	Required	Type	Description
projectName	yes	string	EDT project name (required).
fqn	yes	string	Full-name FQN of the node to modify (required), e.g. 'Catalog.Products' or 'Catalog.Products.Attribute.Weight'; a managed-form root is 'Catalog.Products.Form.ItemForm' or 'CommonForm.Main'. On CommonForm.Main, any mdclass-assignable property keeps the whole call on the mdclass surface; only an all-root-only batch falls back to the content root. Type / kind tokens may be English or Russian; the Name parts are the programmatic Name.
properties	—	array	Properties to set, as [{name, value, language?}]. 'name' is the property name (e.g. 'comment', 'synonym', 'indexing'); 'value' is the new value; 'language' is the code for a synonym (default: config default). Required unless the FQN is a Role and a role payload (rights / templates / roleProperties) is given.
rights	—	array	ROLE only: per-object access rights to set, as [{object, right, value?, rls?, rlsFields?}]. 'object' is a metadata FQN (e.g. 'Catalog.Products' or the Russian 'Справочник.Товары'); 'right' is a bilingual right name (e.g. 'Read'/'Чтение', 'Update'/'Изменение'); 'value' is 'set' (allowed, default) / 'unset' (denied) / 'provided' (default/inherited), or a boolean (true=set, false=unset). 'rls' is an optional Row-Level-Security restriction condition (1C query text); 'rlsFields' is an optional array of field names the RLS applies to (omit / empty = whole-object restriction).
templates	—	array	ROLE only: RLS restriction templates to change, as [{op?, name, condition?}]. 'op' is 'add' (default) / 'edit' / 'delete'; 'name' is the template name; 'condition' is the RLS restriction text (required for add/edit).
roleProperties	—	object	ROLE only: the three role properties, as optional booleans {setForNewObjects, setForAttributesByDefault, independentRightsOfChildObjects}. Only supplied flags are changed.
content	—	array	Members to attach / detach in a structured membership list, dispatched by the FQN's kind (a COMMON ATTRIBUTE's owners, an EXCHANGE PLAN's content objects, a CATALOG's owners, a DOCUMENT's register records, a SUBSYSTEM's content objects), as [{op?, metadata, use?, autoRecord?}]. 'op' is 'add' (default) / 'remove'; 'metadata' is the member object FQN (e.g. 'Catalog.Products' or the Russian 'Справочник.Товары' - only the type token is bilingual). 'use' (CommonAttribute only, add only, default 'Use') is 'Use' / 'DontUse' / 'Auto'; 'autoRecord' (ExchangePlan only, add only) is 'Allow' / 'Deny' (omit to keep the platform default). A Catalog owner, a Document register record and a Subsystem content object are plain references (no flag). Adding is idempotent (a re-added CommonAttribute owner has its 'use' updated, a re-added ExchangePlan object its 'autoRecord'; a re-added plain reference is a no-op). Valid only for a CommonAttribute / ExchangePlan / Catalog / Document / Subsystem FQN (a Subsystem FQN may be nested); cannot be combined with 'properties'.
template	—	object	SpreadsheetDocument (print form / макет) TEMPLATE FQN only: the spreadsheet content to author, instead of 'properties'. An object with any of: 'cells' [{row, col (both 0-based, required), text? OR parameter? (a print-time parameter name), bold?, fontSize?, hAlign? ('Left'/'Center'/'Right'/'Auto'/'Width'), vAlign? ('Top'/'Center'/'Bottom'), wrap? (true word-wraps the cell text)}]; 'merges' [{fromRow, fromCol, toRow, toCol}] merged cell ranges; 'areas' [{name, fromRow, fromCol, toRow, toCol}] named areas (for ПолучитьОбласть / Вывести output); 'columnWidths' [{col, width}] and 'rowHeights' [{row, height}] column / row sizes. Setting a cell overwrites that (row, col); the rest of the content is kept. Valid only for a SpreadsheetDocument template FQN; cannot be combined with 'properties' / 'content' / a Role payload.
normalizeYo	—	boolean	Normalize the Russian letter 'ё'->'е' / 'Ё'->'Е' in localized-string values (synonym / title) and in the 'comment' property (default true). Matches the 1C standard mdo-ru-name-unallowed-letter. Other free-text strings can be identifier-like (e.g. XDTOPackage.namespace is a URI) and always keep the supplied value. Set false to keep 'ё' exactly as supplied everywhere.

Guide

Sets one or more properties of a metadata node addressed by a 1C full-name FQN (a top object, a member, or a managed-form model root), then persists and exports the affected metadata resource (.mdo or Form.form). Replaces the former set_metadata_property (which set only Comment / Synonym); this tool sets any assignable scalar / boolean / integer / enum / many-valued enum / localized-string property. A ROLE FQN (Role.<Name>) is modified through a dedicated access-rights surface (rights / templates / roleProperties) instead of properties - see Setting role access rights. A structured membership LIST is edited through a dedicated content surface instead of properties, dispatched by the FQN's kind - a COMMON ATTRIBUTE's owners (CommonAttribute.<Name>), an EXCHANGE PLAN's content objects (ExchangePlan.<Name>), a CATALOG's owners (Catalog.<Name>), a DOCUMENT's register records (Document.<Name>) or a SUBSYSTEM's content objects (Subsystem.<Name>, including a nested Subsystem.<Parent>.Subsystem.<Child>) - see Editing a membership list (content). A SpreadsheetDocument print-layout TEMPLATE's content is authored through a dedicated template surface instead of properties, on a template FQN (CommonTemplate.<Name> or an object-owned <Type>.<Owner>.Template.<Name>) - see Authoring a spreadsheet template (template).

To read or author DCS schemas, settings variants, or form dynamic lists, use the dedicated dcs tool.

Validation (errors are help)

• A property that is NOT assignable on this node is rejected with the list of assignable properties - discover them with get_metadata_details(assignable:true).
• An ENUM value, including each element of a MANY_ENUM list, that is not one of the allowed literals is rejected WITH the offending value and allowed values; a non-boolean for a boolean property, or a non-integer for an integer property, is rejected too. Nothing is written unless EVERY property validates.
• A ScheduledJob's methodName and an EventSubscription's handler are VALIDATED against the target CommonModule method - see Binding a ScheduledJob / EventSubscription to a method.

Binding a ScheduledJob / EventSubscription to a method (methodName / handler)

Setting a ScheduledJob's methodName or an EventSubscription's handler is VALIDATED against the target CommonModule method BEFORE it is accepted - the referenced method must already EXIST, be Exported, and live in a module with the Server flag (a scheduled job / event-subscription handler always runs server-side). This catches the "bound the job/subscription to a method BEFORE writing it" mistake at validation time, with an actionable error naming the fix, instead of only surfacing it later at update_database as an opaque "no such function" failure.

• A ScheduledJob's methodName and an EventSubscription's handler both STORE CommonModule.<ModuleName>.<MethodName> (e.g. CommonModule.Calc.Add). A bare <ModuleName>.<MethodName> (e.g. Calc.Add) is still ACCEPTED as input and normalized to that canonical stored form; the Russian ОбщийМодуль type-token prefix is accepted too, and a value with no dot is rejected with the expected canonical shape.
• Checks run in order, failing fast on the first that does not hold: the value parses (a module part + a method name); the CommonModule exists (get_metadata_objects lists the available ones); the method exists in that module's source (create it first with write_module_source - an Exported SERVER procedure/function - then set methodName / handler); the method is marked Export (Экспорт); the module has the Server property.
• An EMPTY value is NOT validated by this guard (it falls through to the standard "a property needs a non-empty value" rejection - modify_metadata never clears a property on an empty value).
• Scoped to exactly these two properties (ScheduledJob.methodName, EventSubscription.handler) - every other property on every other FQN is unaffected.

Parameter details

• projectName (required) - EDT project name.
• fqn (required) - full-name FQN of the node.
• properties (required, EXCEPT for a Role FQN with a role payload, a membership FQN with a content payload, or a SpreadsheetDocument template FQN with a template payload) - array of {name, value, language?}. name is the property name; value the new value; language the CODE for a localized property (default: the configuration default). It must be a code the configuration DECLARES (get_configuration_properties -> languages); an undeclared code is REJECTED with the declared list, because a value stored under it is never displayed. A code THIS SAME call declares counts as declared, so one batch may set a Language object's languageCode and a localized value under that very code. A localized write echoes back localesMissing - the languages the configuration ITSELF IS NAMED IN (its own synonym filled in) that still have no translation for at least one of the properties just written - and, when the whole call used exactly ONE code, the language it used (with two codes in one call a single value would misdescribe the other, so it is omitted). A language counts as "in use" only when the configuration's OWN synonym is filled in for it, so a multilingual configuration worked on in a single-language branch is not nagged about the languages nobody is translating into; a configuration whose own synonym is empty in EVERY language reports an EMPTY localesMissing - not every declared code. A write under a DECLARED language the configuration itself is not named in is legal but comes back with localeUnusedInConfiguration: true - ASK the user whether translating into it is really wanted: it may be a single-language build, or a language this configuration does not support yet. Separately, localesStale lists the languages that CARRY TEXT this call left behind, and is reported ONLY when the call REPLACED existing text with a DIFFERENT value - rewriting a property with the SAME string changes nothing, so nothing behind it went out of date. Staleness is decided PER PROPERTY (one receiver's one feature): a call that changes title in en and toolTip in fr reports BOTH languages stale (title's own untouched fr alongside toolTip's own untouched en), while translating both en and fr of the SAME property in one call leaves neither behind. It is optional (and cannot be combined with) the role rights / templates / roleProperties payload (see Setting role access rights), the membership content payload (see Editing a membership list (content)), or the spreadsheet template payload (see Authoring a spreadsheet template (template)).
• content (CommonAttribute / ExchangePlan / Catalog / Document / Subsystem FQN; a Subsystem FQN may be nested) - array of {op?, metadata, use?, autoRecord?} to attach / detach members in the resolved object's structured list (owners / content objects / register records); cannot be combined with properties. See Editing a membership list (content).
• template (SpreadsheetDocument template FQN only - CommonTemplate.<Name> or <Type>.<Owner>.Template.<Name>) - an object {cells?, merges?, areas?, columnWidths?, rowHeights?} authoring the template's spreadsheet content; cannot be combined with properties / content / a Role payload. See Authoring a spreadsheet template (template).
• normalizeYo (optional, default true) - normalize the Russian letter ё->е / Ё->Е in localized-string values (synonym / title) and in the comment property (matches the 1C standard mdo-ru-name-unallowed-letter). Other free-text strings can be identifier-like (e.g. XDTOPackage.namespace is a URI) and always keep the supplied value. Set false to keep ё exactly as supplied everywhere. The result lists the rewritten properties under normalized.

Not supported here

• name (rename): refused - use rename_metadata_object, which cascades the rename across BSL code, forms and metadata.

Setting the data type

The type property takes a STRUCTURED value {types:[{kind, ...}]}. Primitive kinds String / Number / Boolean / Date carry inline qualifiers (length; precision / scale / nonNegative; fractions = DateTime | Date | Time). ValueStorage and UUID are platform simple types with no qualifiers ({kind:'ValueStorage'} / {kind:'UUID'}). ValueTable and ValueTree (bilingual: ТаблицаЗначений / ДеревоЗначений) are IN-MEMORY collections: they are accepted on a FORM attribute (and its columns) ONLY and refused on a stored metadata attribute, which the platform cannot persist - use ValueStorage there instead. A reference is {kind:'Ref', ref:'Type.Name'} (or {kind:'CatalogRef', ref:'Name'}). A produced type is the RUNTIME object a metadata object offers: concrete as {kind:'DocumentObject', ref:'Invoice'} (ref:'Document.Invoice' is equivalent), or abstract when ref is omitted as in {kind:'ExchangePlanObject'}. A FORM attribute accepts the full produced suffix set Object / Manager / Record / RecordSet / RecordManager / ValueManager / RecordKey / List / Selection in either language; for example, set Catalog.Products.Form.ItemForm.Attribute.ProductList with {name:'type', value:{types:[{kind:'CatalogList', ref:'Products'}]}}. An event subscription's source is narrower: it accepts only the event-publishing suffixes Object / Manager / RecordSet / RecordManager / ValueManager because its source must be an object that publishes write events. A produced type of a nested object (a register's Recalculation) is accepted in its abstract form only, for example {kind:'RecalculationRecordSet'} as an event-subscription source; the same kind with a ref is refused. An ordinary persisted attribute refuses a produced type and takes a reference instead. To set EventSubscription.InvoiceEvents.source, pass {name:'source', value:{types:[{kind:'DocumentObject', ref:'Invoice'}]}}; it serializes as <types>DocumentObject.Invoice</types>. A reusable DefinedType accepts {kind:'DefinedType', ref:'Name'}, {kind:'Ref', ref:'DefinedType.Name'}, or {kind:'DefinedType.Name'}; the type token may also use its Russian spelling. The list may mix several (a composite type). If a reference target cannot be resolved AND the project being modified is a configuration EXTENSION, the error additionally suggests adopting the target object from the base configuration first with adopt_metadata_object - a base-configuration object is invisible to an extension's own model until it is adopted.

A FORM attribute takes the whole platform type vocabulary

On a FORM attribute (and its columns) the kind is not limited to the list above: ANY type name the configuration's platform version knows is accepted, in EITHER language - ValueList / СписокЗначений, SpreadsheetDocument / ТабличныйДокумент, Chart, GanttChart, Dendrogram, Planner, GeographicalSchema, GraphicalSchema, TextDocument, FormattedDocument, PDFDocument, StandardPeriod, StandardBeginningDate, TypeDescription, FormattedString, DataCompositionSettingsComposer, Picture, Color, Font, ... These are values the platform holds only in a form's data, so a stored metadata attribute refuses them with an error naming the form attribute as the place they belong.

Nine of them also carry a nested <extInfo> the platform pairs with the type - ValueList -> ValueListExtInfo, SpreadsheetDocument -> SpreadsheetDocumentExtInfo, and so on. That ext-info is created, replaced or cleared automatically when the value type changes, so the attribute is never left half-built; the response reports it as an applied extInfo. A ValueList additionally gets the empty itemValueType the designer writes; set the item type afterwards with a separate {name:'itemValueType', value:{types:[...]}} property.

Separate is not a style preference: because the retype REPLACES the ext-info, batching it with a property that lives on the old holder (itemValueType on a ValueList, say) is refused - one order would discard the property while reporting it as applied, the other would apply it to an EClass that no longer has it. Change the type first, then set the ext-info properties in a second call.

DynamicList is the one type a bare type spec will NOT build: a dynamic list needs its query too, so it is refused with a pointer to the queryText / customQuery / mainTable properties that do build one (see "Dynamic list" below).

Setting an object reference

A reference property to another metadata object is set by FQN: a SINGLE reference (e.g. chartOfAccounts on an AccountingRegister, or a command's group) takes value:'Type.Name'; a LIST reference (e.g. a Subsystem's content) takes value:['Type.Name', ...] and REPLACES the whole list (an empty array [] clears it). Most targets are a top-level object whose type matches; get_metadata_details(assignable:true) shows the allowed target type. Two kinds of reference are member-addressed rather than top-level:

• A default/auxiliary FORM reference (e.g. a DataProcessor's / Catalog's defaultForm) takes the member FQN Type.Name.Form.FormName - the same shape create_metadata uses to create the form - or, when the form is owned by the SAME object being modified, just its bare Name (e.g. value:'ItemForm' on Catalog.Products).
• A template reference (notably Report.mainDataCompositionSchema) takes the member FQN Type.Name.Template.TemplateName. Like forms, templates are BM-managed members with stable IDs and are re-fetched inside the write transaction before assignment.
• A command's group (any <Type>Command, e.g. DataProcessor.X.Command.Y) takes either form: a CommandGroup.<Name> FQN of a configuration command group - a top-level metadata object, create it first with create_metadata fqn:'CommandGroup.<Name>' - or the bare name of one of the platform's built-in STANDARD command groups (ActionsPanelTools, NavigationPanelSeeAlso, FormCommandBarImportant, ...). A standard group is matched case-insensitively against BOTH of the platform's identifiers for it, the English name and the Russian nameRu (ActionsPanelTools / ПанельДействийСервис) - not against the localized UI caption; whichever you send, the platform stores the English name in the .mdo. Each standard group belongs to a category (actions panel, navigation panel, form command bar) that says where it is shown; the platform does not restrict which command may join which group. An unresolvable value is refused with both accepted forms named, and - whenever the platform's group catalogue is reachable - the full list of standard names in both identifiers.

A structured membership list (a common attribute's owners with a per-owner flag, an exchange plan's content objects with an optional autoRecord flag, a catalog's owners, a document's register records, a subsystem's content objects) is edited ADDITIVELY (add / remove ONE member, idempotent) through the sibling content payload - see Editing a membership list (content).

Setting a multi-valued enum

A MANY_ENUM property takes a JSON ARRAY of enum literal strings and is FULL-REPLACE: the supplied array becomes the EXACT list, and an empty array [] clears it. Each literal is resolved case-insensitively through the same enum vocabulary as a scalar ENUM; an unknown literal is rejected with that offending element and the allowed values. get_metadata_details(assignable:true) lists the allowed literals. For example, replace a common form's use purposes with two values: {projectName:'P', fqn:'CommonForm.Main', properties:[{name:'usePurposes', value:['PersonalComputer', 'MobileDevice']}]}.

A bare scalar literal is accepted as shorthand for a ONE-ELEMENT replacement: {projectName:'P', fqn:'CommonForm.Main', properties:[{name:'usePurposes', value:'PersonalComputer'}]} leaves ONLY PersonalComputer; it does not append to the current list.

Setting a StyleItem value (Color / Font)

A StyleItem (created generically with create_metadata) has no value yet; set its value property to a STRUCTURED object with EITHER a color OR a font member (not both). The style item's type (Color / Font) is set automatically to match the value.

• Color (explicit RGB): {name:'value', value:{color:{red:255, green:0, blue:0}}} - each component 0-255.
• Color (automatic): {name:'value', value:{color:'auto'}} - the platform automatic color.
• Color (named): {name:'value', value:{color:{style:'OtherColor'}}} or {name:'value', value:{color:{palette:'Accent'}}} - the named StyleItem / PaletteColor must exist in the project configuration.
• Font: {name:'value', value:{font:{faceName:'Arial', height:12, bold:true, italic:false, underline:false, strikeout:false}}} - at least one of faceName / height / bold / italic / underline / strikeout is required; height is a positive integer. get_metadata_details renders the assigned value under a Value section (Style Type + Color RGB(r, g, b) / Auto, or the Font face / height / flags).

Setting a Picture value

A single contained Picture property (for example a form field's headerPicture / footerPicture) takes one symbolic string:

• StdPicture.<Name> selects a platform standard picture for the project's platform version, e.g. StdPicture.Change.
• StdExtPicture.<Name> selects a platform extended-standard picture.
• CommonPicture.<Name> selects a configuration CommonPicture; the CommonPicture type token may be English or Russian. Use list_common_pictures to discover valid configuration pictures.

For either platform prefix, <Name> may use the picture's English or Russian name. Read-back uses the canonical English name and preserves whether the picture belongs to the standard or extended-standard resource. The stored PictureRef is replaced inside the normal metadata write transaction. An empty value is rejected; this tool does not use an empty picture value as a clear operation. get_metadata_details(assignable:true) renders the current value back in a feedable symbolic form.

Setting an XDTO QName value

The WebService Operation property xdtoReturningValueType and Operation Parameter property xdtoValueType are contained mcore QNames. Supply either the structured object {"name":"string","nsUri":"http://www.w3.org/2001/XMLSchema"} or the compact standard spelling "{http://www.w3.org/2001/XMLSchema}string". Both name and nsUri are required and non-empty. get_metadata_details(assignable:true) renders the current value in compact form.

WebService.xdtoPackages takes a JSON array of strings and replaces the whole package list. Use an existing configuration package FQN such as "XDTOPackage.EnterpriseDataExchange_1_0_1_1" (the type token may also be Russian), or a platform package's namespace URI such as "http://v8.1c.ru/8.1/data/core"; the former is stored as a reference to the configuration XDTOPackage, while the latter has no configuration object and is stored as a string value. Namespace URIs must begin with http://, https://, or urn: so a misspelled metadata FQN is rejected instead of being silently stored as a platform namespace. get_metadata_details(assignable:true) renders the current list back as the same JSON array of strings.

Predefined items (Catalog / ChartOfCharacteristicTypes / ChartOfCalculationTypes / ChartOfAccounts)

A predefined item is addressed by its own FQN, Catalog.X.Predefined.ItemName, ChartOfCharacteristicTypes.X.Predefined.ItemName, ChartOfCalculationTypes.X.Predefined.ItemName or ChartOfAccounts.X.Predefined.AccountName (create it first with create_metadata - see its guide for the grammar, code / isFolder / parent and the full owner-specific property set). properties sets:

• description (string, strict - a JSON string value is required; an explicitly empty string is stored as-is) - the item's presentation text, taken exactly as supplied (no yo-normalization on modify). Validated against the owner's descriptionLength (0 = unlimited; an over-long description is REJECTED, never silently truncated).
• code - matched to the owner's code type (a Catalog / ChartOfCalculationTypes: String or Number per codeType, strict JSON type; a ChartOfCharacteristicTypes / ChartOfAccounts: plain string), validated against codeLength. To CLEAR the code (unset it), pass null as the value OR omit the value entirely (the MCP wire drops a null-valued key, so an omitted value on modify_metadata means the same clear).
• valueType (alias type) - ChartOfCharacteristicTypes items only (rejected for a Catalog item with an actionable error): the item's VALUE TYPE, same {types:[{kind, ...}]} payload shape as an mdclass attribute's type property (see get_metadata_details(assignable:true) on any attribute for the exact shape). To CLEAR the value type, pass null as the value OR omit the value entirely (an omitted value on modify_metadata clears it, matching the null semantics the MCP wire strips).
• isFolder (boolean) - a folder->plain-item change (isFolder:false) is REJECTED while the folder still has children (move or delete them first); item->folder is always allowed. Rejected for a ChartOfCalculationTypes / ChartOfAccounts item (they have no folder concept).
• actionPeriodIsBase (boolean, ChartOfCalculationTypes only) - the calc type's "action period is base" flag.
• accountType / offBalance / order (ChartOfAccounts only) - the account type token (Active / Passive / ActivePassive and their bilingual aliases, matched by EXACT token) / the off-balance boolean / the account order string (validated against the chart's order-length limit, never truncated; pass null or omit the value to clear it).

The multi-valued LIST properties are FULL-REPLACE, symmetric with valueType's clear: the supplied array becomes the EXACT list, OMITTING the property leaves the current list untouched, and an EMPTY array [] CLEARS it. Each entry still resolves to a live target inside the write transaction exactly as at create, and a bad name is rejected:

• base / displaced / leading (ChartOfCalculationTypes only) - the calc type's dependency lists of SIBLING predefined calc-type Names.
• accountingFlags (ChartOfAccounts only) - the Names of the chart's own AccountingFlag objects.
• extDimensionTypes (ChartOfAccounts only) - the account's ext-dimension (subconto) rows [{characteristicType, turnover?, extDimensionAccountingFlags?}]; replaced AS A WHOLE (a row has no identity, so there is no partial per-row edit) - resupply the complete list to change one row.

Every owner-specific property is OWNER-GATED like valueType: a property that does not apply to the addressed owner is rejected with an actionable error.

NOT supported on a predefined item: name (its identity IS the FQN leaf - delete_metadata + create_metadata under the new name instead of renaming), and parent (moving it to a different folder, or re-nesting a ChartOfAccounts account under a different parent account) - both are refused with an actionable error. Discover a predefined item's current properties with get_metadata_details on its FQN, and an owner's whole predefined-item tree with get_metadata_details on the owner FQN (the "Predefined items" section). A predefined item may be addressed by either the normalized or the original ё spelling of its Name (exact-first, then a yo-normalized retry).

Managed-form model root

A managed form's own form:Form model root is addressed by the same FQN used to read its structure. A four-part owned-form FQN such as Catalog.X.Form.F (or any other form-bearing owner type) always targets that content root because no mdclass node exists at the address. The owner type token and the Form token may use their English or Russian spelling; Name segments remain programmatic Names. This edits the properties serialized in Form.form, including title, autoTitle, windowOpeningMode, group, saveDataInSettings, autoSaveDataInSettings, and every other content-root property listed by get_metadata_details(assignable:true) for that form FQN. A localized title uses the supplied language CODE, or the configuration default code when omitted, and receives the same locale report as a member title.

CommonForm.F is dual-purpose because the common form is also a first-class mdclass top object. If at least one requested property name is assignable on that mdclass object, the whole call uses the mdclass surface; this is how synonym, comment, formType, and usePurposes are edited. Only when none of the requested names belongs to the mdclass surface does the call fall back to the content root, allowing root-only properties such as autoTitle. A mixed call stays wholly on the mdclass path and keeps its existing fail-fast behavior. If a fallback property is absent from the content root too, the error lists the root's assignable properties and points to both tables returned by get_metadata_details(assignable:true) on the same FQN. Form-root changes accept only properties, have none of the member-only structural operations below, and are persisted by exporting the content form itself.

Form members

A FORM member is addressed like its create FQN: Catalog.X.Form.F.<Kind>.Name (or CommonForm.F.<Kind>.Name), Kind = Attribute / Command / Parameter / Field / Button / Group / Decoration / Table, or a COLUMN of a collection-typed attribute (...Form.F.Attribute.AttrName.Column.ColName). The <Kind> segment is part of the ADDRESS, not a hint: the member must really be of that kind. An FQN naming another kind (...Button.PriceField for a FIELD) or a misspelt one (...Fielld.PriceField) resolves to nothing and is refused, and the error names the kind the same-named element actually has plus the corrected FQN. A kind token addresses its EClass AND its subclasses, so the designer's own children have exactly one supported address too: an AutoCommandBar / ContextMenu / actions panel IS a Group (...Group.FormCommandBar), an ExtendedTooltip IS a Decoration (...Decoration.PriceExtendedTooltip). A table addition (search string / view status / search control) is the one element no kind token names, so no FQN addresses it: it is created and removed together with its table. A form PARAMETER takes exactly three: valueType (the same {types:[...]} shape a form attribute takes), the boolean keyParameter, and comment - it has no title and no position, so it is neither localized nor movable. The same assignable properties apply: an item's title (bilingual; defaults to the config language when language is omitted), visible, readOnly (fields / groups / tables only) and any other assignable scalar / boolean / enum the item carries. NB type is context-dependent: on a form ATTRIBUTE it aliases the data valueType (same {types:[...]} shape as an mdclass attribute); on a form FIELD / Button / Decoration / Group it is the display-kind ENUM (InputField / LabelField / CheckBoxField / ... ; Label / Picture ; UsualGroup / Pages / Page / CommandBar / ButtonGroup / Popup / ColumnGroup / ContextMenu / Navigator / RowActionsPanel / SelectedItemsActionsPanel / AutoCommandBar). That ENUM is a CLASSIFIER, not a cosmetic flag: it decides which concrete <extInfo> the item carries, so changing it also re-pairs the ext-info in the same call - created, replaced, or cleared for the group types that pair with none - and the response reports it as an applied extInfo. Because the ext-info's EClass is decided by the type, a type change cannot be combined with a property that lives ON the ext-info in one call; change the type first, then set the layout properties. A wrong property name is rejected WITH the member's assignable list. The form item id cannot be set (auto-allocated). The change persists to the form's Form.form on disk.

Adjustable flags (view / edit / userVisible / use)

A few form flags are stored NOT as a plain boolean but as a nested object carrying a common flag plus optional per-role overrides. You set them with a plain boolean anyway - the value addresses common, e.g. {name:'view', value:true}. They are: a form ATTRIBUTE's (and attribute COLUMN's) view and edit, a form ITEM's userVisible, a form COMMAND's use. Any per-role overrides already stored alongside the flag are PRESERVED - setting the boolean rewrites common only and never replaces the object. get_metadata_details(assignable:true) reports the current common value (blank when the flag has never been set). New attributes and columns are created with view/edit already set, exactly as the EDT designer creates them - a form attribute written WITHOUT them makes the configuration unloadable (the platform's XDTO reader rejects the generated Form.xml), so set them on any attribute that predates this behaviour.

Rebinding a form event handler / a button's command

Two form links are not ordinary assignable properties and have their own rebind paths (both force-export the Form.form):

• REBIND a handler's procedure: address the EXISTING handler by its FQN Catalog.X.Form.F.Handler.<Event> (form-level), Catalog.X.Form.F.<ItemKind>.<ItemName>.Handler.<Event> (item-level) or Catalog.X.Form.F.Command.<Name>.Handler.Action (a command's Action) and pass a procedure property with the new BSL procedure name. This only re-points an existing handler; to BIND a new event use create_metadata, to remove it delete_metadata. A handler FQN accepts no other property.
• RE-POINT a button at a different command: address the Button by its FQN Catalog.X.Form.F.Button.<Name> and pass a command property (the button's commandName targets a form-model object, so it is rebound here rather than via a generic reference). The value names either a CUSTOM form command, which must already exist, or a platform STANDARD command of a source the button may use - the form itself, or a table / field. A bare name resolves custom-first, then the button's own item source, then the form; StandardCommand.<Name> forces the form's own, and Item.<ItemName>.StandardCommand.<Name> names another item's (e.g. a filter button beside a list binding that list's AddFilterItem). A standard command answers to its English or its Russian name, and an unresolved name is refused WITH the standard commands available to that button. A command change cannot be combined with other property changes in one call.

Moving / reordering a form item

A FORM ITEM (a field / group / decoration / button / table - anything in the form's items tree) is RE-PARENTED and/or REORDERED with two move properties on properties:

• parent - the destination: an existing container name (a group, a table) to nest the item inside, the special AutoCommandBar token for the form's command bar (MyTable.AutoCommandBar for a table's own bar), or the FORM name (or an empty string) to move it to the form ROOT. Omit parent to keep the current parent (a pure reorder).
• position - the destination order among the children: first, last, before:<siblingName>, after:<siblingName>, or a 0-based integer INDEX. The integer index is the desired FINAL position "as you see it" (reordering within the same container is not off-by-one). Omit position to append to the end of the destination. Out-of-range handling is deliberately asymmetric: an integer index past the last position is CLAMPED to the end (tolerant, like list APIs), while before:/after: naming an unknown sibling is an ERROR (an explicit sibling reference asserts the form's current structure, so a stale name must surface instead of being silently re-interpreted). A move is structural, so it CANNOT be combined with ordinary property changes in the same call (move first, then modify). parent/position apply to an ITEM only - a form Attribute / Command is not positioned. The same placement rules as create apply (e.g. no decorations in command bars); a button's CommandBarButton/UsualButton type re-derives when it crosses a bar boundary; the designer auto-children (tooltips / context menus / command bars) are not movable. A group cannot be moved into ITSELF or one of its own descendants (a cycle); an ambiguous / missing item or an unknown parent is a clean error. The move force-exports the form's Form.form to disk; the result carries a destination describing where the item ended up.

Setting a dynamic-list custom query

A list / choice form shows its rows through a dynamic list form attribute. To give it a CUSTOM query (e.g. a multilingual name from a common attribute, a calculated column, or an in-query filter) set the query on that ATTRIBUTE - addressed Catalog.X.Form.ListForm.Attribute.<Name>:

• queryText - the 1C query, e.g. SELECT Ref, Description AS Description FROM Catalog.Products. Setting it turns the attribute into a dynamic list (if it is not one already) and implies customQuery=true.
• customQuery - true to use the custom queryText, false to switch the dynamic list back to its automatic main-table query (the queryText is kept but ignored while false).
• mainTable (optional) - the FQN of the object the list reads from, e.g. Document.Order / Catalog.Products. It is resolved to the object's main-table view; setting it enables the list's available-table fields and dynamic data reading. The list is valid without it (the query's FROM defines the source).

When the attribute is not yet a dynamic list it is converted: a DynamicList value type and a dynamic-list ext-info are created, the form's main attribute is set when it has none, and autoFillAvailableFields is turned on so EDT derives the available <fields> from the query - you do NOT author a DCS <fields> block. Create the bare attribute first (create_metadata with ...Form.ListForm.Attribute.List), then set its query here. Output a column with create_metadata for a form Field bound to dataPath List.<field> (e.g. List.Number), where <field> is a query select field; the Field shows that query column in the list table. The query props are structural, so they cannot be combined with other property changes in one call (set the query first, then make other changes). A non-existent attribute or a malformed FQN is a clean error. The change force-exports the form's Form.form to disk; verify with get_project_errors (an invalid query is reported by the platform's dynamic-list validation). Property names are bilingual: ru ТекстЗапроса / ПроизвольныйЗапрос / ОсновнаяТаблица.

Setting role access rights

When the fqn is a Role (Role.<Name>) you set the role's ACCESS RIGHTS through three sibling payload keys instead of properties - a role is modified through its rights surface, not the generic property bag. All three keys are optional; give any combination in one call. A role payload CANNOT be combined with a generic properties change in the same call (set the role's own comment / synonym separately). Read a role's current rights matrix, RLS restrictions and templates with get_metadata_details on the Role FQN. The change goes through the EDT-native rights tasks and force-exports TWO FQNs - the role's own Role.<Name> and the rights description's OWN top-object FQN - because the rights matrix is a SEPARATE BM top object living in its own Rights.rights resource, which the role FQN alone does not drain. persisted: false in the result means the rights resource was not force-exported - either its OWN top-object FQN could not be produced (only the role's .mdo was queued) or the export submission was not accepted (nothing was queued at all) - so the applied counts describe the model, not the file. persisted: true means a save task was ACCEPTED for at least one of the two FQNs, not that the rights bytes are on disk.

• rights - array of {object, right, value?, rls?, rlsFields?} (per-object right VALUES + optional per-object Row-Level-Security):
  • object (required) - the guarded metadata FQN, e.g. Catalog.Products or the Russian Справочник.Товары (only the type token is bilingual; the Name is the programmatic Name).
  • right (required) - a bilingual right name, e.g. Read / Чтение, Update / Изменение, Insert / Добавление. An unknown right is rejected WITH the list of valid rights for that object type.
  • value (optional, default set) - set (allowed) / unset (denied) / provided (default / inherited), or a boolean (true=set, false=unset). A value that equals the object's CURRENT default in this role is not authored at all - see the pruning note below.
  • rls (optional) - a Row-Level-Security restriction condition (1C query text). Setting it adds (or edits, if one already exists for that object+right) the RLS restriction.
  • rlsFields (optional) - an array of field names the RLS applies to; omit or leave empty for a WHOLE-OBJECT restriction. Field names are matched bilingually against the object's RLS field pool.
• templates - array of {op?, name, condition?} (RLS restriction templates):
  • op (optional, default add) - add / edit / delete.
  • name (required) - the template name.
  • condition (required for add / edit) - the RLS restriction text.
• roleProperties - object of optional booleans {setForNewObjects, setForAttributesByDefault, independentRightsOfChildObjects} - the three role-wide flags. Only supplied flags are changed.

applied.rights counts the entries you SUBMITTED, not the cells written. The platform does not author a right whose value already equals the object's current default in this role: such an entry is pruned and nothing for it lands in Rights.rights - re-read with get_metadata_details to see what actually landed. That default comes from the role-wide flags - setForNewObjects for a top object, setForAttributesByDefault for an attribute / tabular section / dimension / resource - and a role created through create_metadata starts with BOTH flags false, so on such a role value: "unset" on a top object writes nothing until you turn the flag on. roleProperties are applied AFTER rights[] inside one call, so a flag sent alongside the cells does not change the default those cells were measured against - set it in a separate, earlier call.

An unknown right, a bad object FQN or an unknown RLS field is a clean, actionable error (not-found + the valid list / a suggestion), and it is raised BEFORE anything is written: the WHOLE rights[] payload - object, right, value and RLS fields - is resolved before the role's rights model is bootstrapped and before the first task commits. Such a refusal therefore leaves the role exactly as it found it, and in particular never leaves a right GRANTED whose RLS restriction could not be resolved. Two later failures can still leave a partial change: a rights task that fails mid-batch, and templates[] / roleProperties, which resolve only after the rights plan has been applied (an edit / delete template needs the rights model to exist). A refusal of that kind says so in its error text and reports applied: {rights, templates, roleProperties} - the counts it had already committed - alongside mutationCommitted: true. Re-read the role with get_metadata_details to see what actually landed before re-sending a corrected payload.

Editing a membership list (content)

Several metadata objects carry a structured MEMBERSHIP list - which objects they include or apply to. You edit that list through the sibling content payload instead of properties, dispatched by the resolved FQN's kind. The list is edited through its own surface, not the generic property bag, so a content payload CANNOT be combined with a generic properties change in the same call (set the object's own comment / synonym separately). The change goes through a BM write transaction and force-exports the addressed object's .mdo to disk once (no manual clean_project needed). Read the current list with get_metadata_details on the FQN.

The five supported kinds:

• CommonAttribute (CommonAttribute.<Name>) - a single attribute shared across many objects (an audit Author / EditDate, a data-separator). Its OWNERS live in the content list, each with a per-owner use flag (Use / DontUse / Auto, default Use).
• ExchangePlan (ExchangePlan.<Name>) - the plan's CONTENT objects (which objects participate in the exchange), each with an optional autoRecord flag (Allow / Deny; omit to keep the platform default) that governs auto-registration of changes.
• Catalog (Catalog.<Name>) - the catalog's OWNERS (a subordinate catalog is owned by one or more objects). A plain reference - no per-owner flag.
• Document (Document.<Name>) - the document's REGISTER RECORDS / движения (the registers the document posts to). A plain reference - no per-record flag.
• Subsystem (Subsystem.<Name>, or a NESTED Subsystem.<Parent>.Subsystem.<Child> - bilingual, so Подсистема.<Name> works too) - the subsystem's CONTENT objects (the metadata that belongs to this subsystem in the metadata tree). A plain reference - no flag. A member may be ANY top-level configuration object (a Constant, Catalog, Document, Report, DataProcessor, register, CommonModule, Role, ...) EXCEPT another Subsystem: subsystems nest through their own hierarchy, not through content. This additive path adds / removes ONE member and is idempotent (unlike setting the content PROPERTY, which replaces the whole list). The allow-list of valid member kinds is extensible - a missing kind is rejected with an actionable error naming the FQN and its kind.

For a CommonAttribute, the target's own LIVE dataSeparation value selects the owner rule. The sets are intentionally asymmetric; they must not be combined:

• Simple common attribute (dataSeparation is not Separate, normally DontUse) - valid owner kinds are ExchangePlan, AccountingRegister, AccumulationRegister, ChartOfAccounts, ChartOfCharacteristicTypes, Document, InformationRegister, DocumentJournal, Catalog, BusinessProcess, Task, ChartOfCalculationTypes, and CalculationRegister.

• SEPARATOR common attribute (dataSeparation=Separate) - valid owner kinds are ExchangePlan, ScheduledJob, AccountingRegister, AccumulationRegister, ChartOfAccounts, ChartOfCharacteristicTypes, Constant, Document, InformationRegister, Catalog, BusinessProcess, Task, ChartOfCalculationTypes, and CalculationRegister. Thus a Constant or ScheduledJob can own a separator but not a simple common attribute, while a DocumentJournal can own a simple common attribute but not a separator.

• content - array of {op?, metadata, use?, autoRecord?}:

  • op (optional, default add) - add attaches (or updates) a member; remove detaches one by its metadata FQN.
  • metadata (required) - the member object FQN, e.g. Catalog.Products or the Russian Справочник.Товары (only the type token is bilingual; the Name is the programmatic Name). It must exist and be a valid member kind for the target list; otherwise the entry is rejected with an actionable error (for a CommonAttribute, an owner from the set selected by the target's live dataSeparation; a Catalog owner; an ExchangePlan content object; a Document register - a BasicRegister: Information / Accumulation / Accounting / Calculation; a Subsystem content object - any top-level configuration object except another Subsystem).
  • use (CommonAttribute only, optional, add only, default Use) - the per-owner usage: Use / DontUse / Auto. Ignored for remove and for the other kinds.
  • autoRecord (ExchangePlan only, optional, add only) - Allow / Deny. Omit to keep the platform default. Ignored for remove and for the other kinds.

Adding is IDEMPOTENT: attaching a member already listed does not duplicate it. For a CommonAttribute / ExchangePlan (a wrapper list with a per-entry flag) a re-add UPDATES that member's flag (use / autoRecord, counted under updated rather than added); for a Catalog owner / Document register record / Subsystem content object (a plain reference, no flag) a re-add is a no-op. Removing a member that is not listed is a clean error. Nothing is written unless every entry resolves. The result's content counts object is {added, updated, removed} for a CommonAttribute / ExchangePlan change and {added, removed} for a Catalog owners / Document register records / Subsystem content change.

Authoring a spreadsheet template (template)

A SpreadsheetDocument template (a "Табличный документ" / print form / макет - the layout used for invoices, acts and printed reports) has its cell content authored through the template payload instead of properties, on a template FQN. Create the empty template OBJECT first with create_metadata (CommonTemplate.<Name> for a shared template, or <Type>.<Owner>.Template.<Name> for an object-owned one - e.g. DataProcessor.Invoices.Template.Printout); it is a SpreadsheetDocument template by default. Then fill its content here. Only a SpreadsheetDocument-typed template can be authored (a text / binary-data / DCS / graphical template is refused with its actual type). A template payload cannot be combined with properties, a membership content payload or a Role payload in the same call; a template payload on a non-template FQN is a clean, actionable error. The change goes through a BM write transaction and force-exports the template's .mxlx content to disk once (no manual clean_project). Render the result to a PNG with get_template_screenshot to visually verify it.

The template object takes any of these arrays (all optional; omit an array to leave that aspect untouched):

• cells - [{row, col, text?, parameter?, bold?, fontSize?, hAlign?, vAlign?, wrap?}]:
  • row, col (required) - the 0-based row and column index of the cell.
  • text - a static text value shown in the cell. A cell is either text OR a parameter, not both.
  • parameter - the name of a print-time PARAMETER (filled by BSL at output, e.g. via ОбластьМакета.Параметры.<Name>); the cell shows the parameter's value when the template is printed.
  • bold - true to embolden the cell font.
  • fontSize - the font size (points), a positive integer.
  • hAlign - horizontal alignment: Left / Center / Right / Auto / Width.
  • vAlign - vertical alignment: Top / Center / Bottom.
  • wrap - true to word-wrap the cell text (otherwise a single line).
  • Setting a cell OVERWRITES that (row, col) cell; the rest of the content is kept (authoring is additive per cell, not a whole-content replace).
• merges - [{fromRow, fromCol, toRow, toCol}]: a merged rectangular cell range (0-based, inclusive).
• areas - [{name, fromRow, fromCol, toRow, toCol}]: a NAMED area over a cell range, for programmatic ПолучитьОбласть("<name>") / Вывести output from BSL.
• columnWidths - [{col, width}]: the width of a column (0-based index).
• rowHeights - [{row, height}]: the height of a row (0-based index).

A malformed entry (a bad alignment / placement token, a missing row / col, a non-positive size) is a clean error and nothing is written. The result carries a template counts object {cells, merges, areas, columnWidths, rowHeights} (how many of each were applied).

Examples

• Move a field into a group: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Field.Price', properties:[{name:'parent', value:'PriceGroup'}]}
• Move a button into the command bar: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Button.Print', properties:[{name:'parent', value:'AutoCommandBar'}]}
• Reorder a field to the top of its container: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Field.Price', properties:[{name:'position', value:'first'}]}
• Move a field back to the form root, after another item: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Field.Price', properties:[{name:'parent', value:'ItemForm'}, {name:'position', value:'after:Description'}]}
• Set a comment: {projectName:'P', fqn:'Catalog.Products', properties:[{name:'comment', value:'Goods'}]}
• Set a synonym: {projectName:'P', fqn:'Catalog.Products', properties:[{name:'synonym', value:'Goods', language:'en'}]}
• Set an enum on an attribute: {projectName:'P', fqn:'Catalog.Products.Attribute.Weight', properties:[{name:'indexing', value:'Index'}]}
• Bind a scheduled job to an existing Exported server method (validated): {projectName:'P', fqn:'ScheduledJob.NightlyRecalc', properties:[{name:'methodName', value:'CommonModule.Calc.Add'}]}
• Bind an event-subscription handler (validated, CommonModule. prefix form): {projectName:'P', fqn:'EventSubscription.OnWrite', properties:[{name:'handler', value:'CommonModule.Calc.Add'}]}
• Set a type: {projectName:'P', fqn:'Catalog.Products.Attribute.Weight', properties:[{name:'type', value:{types:[{kind:'Number', precision:10, scale:2}]}}]}
• Set a list reference: {projectName:'P', fqn:'Subsystem.Sales', properties:[{name:'content', value:['Catalog.Products', 'Document.Order']}]}
• Set a DataProcessor's default form by the full member FQN: {projectName:'P', fqn:'DataProcessor.Invoices', properties:[{name:'defaultForm', value:'DataProcessor.Invoices.Form.ItemForm'}]}
• Set a default form by its bare Name (shorthand for a form owned by the same object): {projectName:'P', fqn:'DataProcessor.Invoices', properties:[{name:'defaultForm', value:'ItemForm'}]}
• Set a command's group: {projectName:'P', fqn:'DataProcessor.Invoices.Command.Print', properties:[{name:'group', value:'CommandGroup.PrintCommands'}]}
• Disable the automatic title on a managed-form root: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm', properties:[{name:'autoTitle', value:false}]}
• Hide a form item: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Field.Price', properties:[{name:'visible', value:false}]}
• Set a form attribute's type: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Attribute.Total', properties:[{name:'type', value:{types:[{kind:'Number', precision:10, scale:2}]}}]}
• Give a list form a custom dynamic-list query: {projectName:'P', fqn:'Catalog.Products.Form.ListForm.Attribute.List', properties:[{name:'queryText', value:'SELECT Ref, Description AS Description FROM Catalog.Products'}, {name:'customQuery', value:true}]}
• Set the dynamic list's main table: {projectName:'P', fqn:'Catalog.Products.Form.ListForm.Attribute.List', properties:[{name:'mainTable', value:'Catalog.Products'}]}
• Switch a dynamic list back to its automatic query: {projectName:'P', fqn:'Catalog.Products.Form.ListForm.Attribute.List', properties:[{name:'customQuery', value:false}]}
• Rebind an item-level handler's procedure: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Field.Price.Handler.OnChange', properties:[{name:'procedure', value:'PriceOnChange'}]}
• Re-point a button at another command: {projectName:'P', fqn:'Catalog.Products.Form.ItemForm.Button.Go', properties:[{name:'command', value:'Refresh'}]}
• Set a style item to a red color: {projectName:'P', fqn:'StyleItem.MyColor', properties:[{name:'value', value:{color:{red:255, green:0, blue:0}}}]}
• Set a style item to the automatic color: {projectName:'P', fqn:'StyleItem.MyColor', properties:[{name:'value', value:{color:'auto'}}]}
• Set a style item to a font: {projectName:'P', fqn:'StyleItem.MyFont', properties:[{name:'value', value:{font:{faceName:'Arial', height:12, bold:true}}}]}
• Grant a role a right on an object: {projectName:'P', fqn:'Role.FullAccess', rights:[{object:'Catalog.Products', right:'Read', value:'set'}]}
• Deny a right (bilingual right name): {projectName:'P', fqn:'Role.FullAccess', rights:[{object:'Справочник.Товары', right:'Изменение', value:'unset'}]}
• Add a whole-object RLS restriction: {projectName:'P', fqn:'Role.Sales', rights:[{object:'Catalog.Products', right:'Read', value:'set', rls:'WHERE Ref.Company = &Company'}]}
• Add a per-field RLS restriction: {projectName:'P', fqn:'Role.Sales', rights:[{object:'Catalog.Products', right:'Read', value:'set', rls:'WHERE Ref.Company = &Company', rlsFields:['Price', 'Cost']}]}
• Add an RLS restriction template: {projectName:'P', fqn:'Role.Sales', templates:[{op:'add', name:'ByCompany', condition:'WHERE Company = &Company'}]}
• Set the role-wide flags: {projectName:'P', fqn:'Role.Sales', roleProperties:{setForNewObjects:true, setForAttributesByDefault:false}}
• Attach an owner to a common attribute: {projectName:'P', fqn:'CommonAttribute.Author', content:[{metadata:'Catalog.Products', use:'Use'}]}
• Attach several owners (bilingual FQN): {projectName:'P', fqn:'CommonAttribute.Author', content:[{op:'add', metadata:'Document.Order'}, {op:'add', metadata:'Справочник.Товары', use:'Auto'}]}
• Detach an owner: {projectName:'P', fqn:'CommonAttribute.Author', content:[{op:'remove', metadata:'Catalog.Products'}]}
• Add an object to an exchange plan's content with auto-record allowed: {projectName:'P', fqn:'ExchangePlan.Branches', content:[{metadata:'Catalog.Products', autoRecord:'Allow'}]}
• Add an exchange plan content object, denying auto-record (bilingual FQN): {projectName:'P', fqn:'ExchangePlan.Branches', content:[{op:'add', metadata:'Документ.Заказ', autoRecord:'Deny'}]}
• Detach an exchange plan content object: {projectName:'P', fqn:'ExchangePlan.Branches', content:[{op:'remove', metadata:'Catalog.Products'}]}
• Add an owner to a subordinate catalog: {projectName:'P', fqn:'Catalog.Contacts', content:[{metadata:'Catalog.Partners'}]}
• Detach a catalog owner: {projectName:'P', fqn:'Catalog.Contacts', content:[{op:'remove', metadata:'Catalog.Partners'}]}
• Add a register record / движение to a document: {projectName:'P', fqn:'Document.Order', content:[{metadata:'AccumulationRegister.Goods'}]}
• Detach a document register record: {projectName:'P', fqn:'Document.Order', content:[{op:'remove', metadata:'AccumulationRegister.Goods'}]}
• Add an object to a subsystem's content: {projectName:'P', fqn:'Subsystem.Sales', content:[{metadata:'Constant.CompanyName'}]}
• Add several objects to a nested subsystem (bilingual FQN): {projectName:'P', fqn:'Subsystem.Sales.Subsystem.Orders', content:[{op:'add', metadata:'Catalog.Products'}, {op:'add', metadata:'Документ.Заказ'}]}
• Detach an object from a subsystem's content: {projectName:'P', fqn:'Subsystem.Sales', content:[{op:'remove', metadata:'Constant.CompanyName'}]}
• Author a title cell in a common template: {projectName:'P', fqn:'CommonTemplate.InvoiceForm', template:{cells:[{row:0, col:0, text:'INVOICE', bold:true, fontSize:14, hAlign:'Center'}], merges:[{fromRow:0, fromCol:0, toRow:0, toCol:3}]}}
• Add a print-time parameter cell and a named area to an object-owned template: {projectName:'P', fqn:'DataProcessor.Invoices.Template.Printout', template:{cells:[{row:2, col:1, parameter:'CustomerName', wrap:true, vAlign:'Center'}], areas:[{name:'Header', fromRow:0, fromCol:0, toRow:1, toCol:3}]}}
• Set column widths and a row height: {projectName:'P', fqn:'CommonTemplate.InvoiceForm', template:{columnWidths:[{col:0, width:30}, {col:1, width:60}], rowHeights:[{row:0, height:24}]}}
• Set a predefined account's type and off-balance flag: {projectName:'P', fqn:'ChartOfAccounts.Main.Predefined.Cash', properties:[{name:'accountType', value:'Active'}, {name:'offBalance', value:false}]}
• Full-replace a calc type's base list (empty array clears it): {projectName:'P', fqn:'ChartOfCalculationTypes.Accruals.Predefined.Bonus', properties:[{name:'base', value:['Salary', 'Overtime']}]}
• Replace a predefined account's ext-dimension rows as a whole: {projectName:'P', fqn:'ChartOfAccounts.Main.Predefined.Settlements', properties:[{name:'extDimensionTypes', value:[{characteristicType:'Counterparties', turnover:false}]}]}

Result

JSON with action='modified', the normalized fqn, the applied property names, persisted, and (when the ё->е normalization rewrote anything) the list of normalized properties. A move additionally returns destination (where the moved item ended up, e.g. group 'Main' at index 1). For a ROLE rights change applied is instead a counts object {rights, templates, roleProperties} (how many of each were applied). For a membership content change the result carries a content counts object: {added, updated, removed} for a CommonAttribute / ExchangePlan change (members attached / had their use / autoRecord flag updated / detached) and {added, removed} for a Catalog owners / Document register records / Subsystem content change (a plain reference list has no per-entry flag, so nothing is "updated"). For a template spreadsheet-content change the result carries a template counts object {cells, merges, areas, columnWidths, rowHeights} (how many of each were applied).

Reverting (no undo)

There is no automatic undo: to revert a change, call modify_metadata again with the previous value (read the current value first with get_metadata_details). modify_metadata is intentionally NOT confirm-gated because it is reversible that way; only the destructive / high-blast-radius writes (delete_metadata, rename_metadata_object, update_database, delete_project) are gated with a confirm-preview.

Predefined items

A PREDEFINED item is addressed through its owner's member FQN and is edited like any other member.

---

Generated from the live MCP server (get_tool_guide) by docs/generate_tool_docs.py. Do not edit this file. Edit the tool's description/schema in its Java source and its guide body in mcp/bundles/com.ditrix.edt.mcp.server/guides/<tool>.md.