Application-level state: active window, child objects, errors, dialogs, limits. Common operations for objects of this type live elsewhere: tc_field(action="is_visible"), tc_field(action="is_enabled"), tc_field(action="get_context_menu"). In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. Actions:

• clear_file_dialog_result() Clear a previously set file-dialog result. (1C 8.3.25+)

• get_active_window() Return the application's active window: {ref, class, title, platform_version} and sometimes form_name. title is the caption of the window's managed form — null only when the window has no form or the caption could not be read. form_name is the form's name in the configuration metadata ('Справочник.Контрагенты.Форма.ФормаСписка'), unrelated to name, which for a form is a GUID. form_name is read only when the window itself gave no caption and may be absent even then: its absence says nothing about the form. To read it explicitly call tc_app(action="get_child_objects") on the window ref. platform_version is the version of this connection; actions unavailable on it are refused with available_since. addressable=false means the window has no element address; this alone does not identify its type. When local recovery is unavailable, code=active_window_unavailable explains how to continue. A local print preview may report native=true and recovery="close_window": close it to return to the form before addressing form elements. (1C 8.3.3+)

• get_child_objects(ref=null) List one level of child UI objects under the addressed parent. If its address is omitted, use the last observed active window, querying the client if no window has been observed. For a whole subtree in one call use tc_find(action="find_objects"). Returns an object with parent and children: [...]. Child metadata includes class and title; name and type may also be present. type names a recognized platform element kind (e.g. CheckBoxField or Pages), and may be null when no kind is known for that object. A ManagedForm row can also carry form_name, its name in configuration metadata (e.g. 'Справочник.Контрагенты.Форма.ФормаСписка'), useful when the title is empty. Always obtain object addresses from tool results. Address the parent with ref; children contain ref values. For a whole subtree, pass root_ref to tc_find(action="find_objects"). (1C 8.3.3+)

• get_current_error() Get info about the session's last CLIENT error (none → null). error is the main description; details preserves additional text, including nested causes, module locations and stacks. This is not where an application refusal shows up: messages raised by the configuration ("field not filled in", "posting is not possible") arrive in tc_window(action="get_user_message_texts"). Read that one with care — it returns the ACCUMULATED messages of the session, so an old complaint is still there after a later action succeeded; clear it with tc_window(action="close_user_messages_panel") before the action you want to judge. (1C 8.3.3+)

• get_max_action_time() Get the max action-execution time in seconds (set via tc_app(action="set_max_action_time"); None if unset).

• get_parent(ref*) Get an element's parent in parent: [...]. The server resolves the parent's own address and returns it with the available object metadata. Address the element with ref; objects in parent contain their own ref values. (1C 8.3.24+)

• get_performance(clear=False) Get accumulated session performance counters (calls, duration, sent, received). Set clear to also reset them, so the next read measures only what happened after this call. (1C 8.3.6+)

• set_file_dialog_result(result=True, filename=null, filter_index=0) Predefine the next file dialog's result: result=True + filename to simulate picking a file, result=False to cancel. Pass a list of names to simulate a multi-file selection. filter_index selects which dialog filter is active (0-based). Replaces any previous pending answer. The next file dialog consumes it; clear_file_dialog_result cancels an unused answer. (1C 8.3.8+)

• set_max_action_time(seconds*) Set the max action-execution time in seconds: how long a result-returning action may take before the call gives up (0 = wait indefinitely). Stored on the client (no network call) and applied to every subsequent command. connection_id selects the client. Passing ref selects the client automatically; otherwise, with several clients, connection_id is required. Use tc_session(action="list_connections"). Pass reference values returned by the tools unchanged in ref. If a reference expires, find the element again.

Actions on a calendar field. Common operations for objects of this type live elsewhere: tc_field(action="is_visible"), tc_field(action="is_enabled"), tc_field(action="get_context_menu"), tc_app(action="get_parent"). In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. ok: true means the client accepted the command, not that anything changed — confirm an effect by reading the state back; target_check: present is not proof of one either. Where the address can be checked the response carries target_check: present, unknown (not checkable here) or off (checking disabled). target_hidden: true appears ONLY when the target exists and was NOT visible; it does NOT prove the absence of an effect — for tc_field(action="activate") invisibility is the normal precondition — it describes the ELEMENT itself and not an invisible container around it, and its absence says nothing. A wrong address is refused with an error only where the address can be checked: a read without a target marker cannot tell one from an empty answer, and tc_table(action="get_cell_text") on a table that does not exist returns text=null exactly as for an empty cell. Actions:

• calendar_next_month(ref*) Move a calendar field to the next month. The command is accepted, but nothing readable about the field changes, so this cannot be verified. To move the date use tc_calendar(action="goto_date").

• calendar_next_year(ref*) Move a calendar field to the next year. The command is accepted, but nothing readable about the field changes, so this cannot be verified. To move the date use tc_calendar(action="goto_date").

• calendar_previous_month(ref*) Move a calendar field to the previous month. The command is accepted, but nothing readable about the field changes, so this cannot be verified. To move the date use tc_calendar(action="goto_date").

• calendar_previous_year(ref*) Move a calendar field to the previous year. The command is accepted, but nothing readable about the field changes, so this cannot be verified. To move the date use tc_calendar(action="goto_date").

• goto_date(ref*, year*, month*, day*) Go to a date (year, month, day) in a calendar field. Returns changed/value_before/value_after. connection_id selects the client. Passing ref selects the client automatically; otherwise, with several clients, connection_id is required. Use tc_session(action="list_connections"). Pass reference values returned by the tools unchanged in ref. If a reference expires, find the element again.

Actions on document fields and spreadsheet areas. Choose action. Common operations for objects of this type live elsewhere: tc_field(action="is_visible"), tc_field(action="is_enabled"), tc_field(action="get_context_menu"), tc_app(action="get_parent"). In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. ok: true means the client accepted the command, not that anything changed — confirm an effect by reading the state back; target_check: present is not proof of one either. Where the address can be checked the response carries target_check: present, unknown (not checkable here) or off (checking disabled). target_hidden: true appears ONLY when the target exists and was NOT visible; it does NOT prove the absence of an effect — for tc_field(action="activate") invisibility is the normal precondition — it describes the ELEMENT itself and not an invisible container around it, and its absence says nothing. A wrong address is refused with an error only where the address can be checked: a read without a target marker cannot tell one from an empty answer, and tc_table(action="get_cell_text") on a table that does not exist returns text=null exactly as for an empty cell. Actions:

• begin_edit_current_area(ref*) Start editing the current spreadsheet-document area. Follow with input_text then end_edit_current_area to commit a new cell value. On a field that does NOT allow editing this does something else entirely: it runs the current cell's DETAILS — the platform's drill-down. It opens the object behind the cell, or a field chooser for a total, and choosing a row there gives the drill-down report. Set the current cell with set_current_area first.

• click_formatted_doc_hyperlink(ref*, index*) Click a hyperlink in a formatted-document field by 0-based index (or by its text). On a document without links the platform answers the same and puts up its own error window, and tc_doc(action="get_formatted_string_hyperlinks") cannot be used to check first: for a formatted DOCUMENT it answers with an empty list even when the document does have a link (it lists links only for a formatted-string label). Judge by what the click was supposed to do. (1C 8.3.25+)

• click_formatted_string_hyperlink(ref*, index*) Click a hyperlink in a formatted string by 0-based index (or by its text). ref may be a label field or a form decoration bearing the formatted string. (1C 8.3.13+)

• click_html_hyperlink(ref*, index*) Click a hyperlink in an HTML-document field. The platform clicks the FIRST link whatever you pass: measured with three links and an index of 0, 1 and 2, and the same encoding the platform's own test manager sends. An index beyond the number of links is refused, so the argument is read — it just does not choose. Addressing by text does nothing at all here. (1C 8.3.25+)

• end_edit_current_area(ref*, cancel=False) Finish editing the current spreadsheet-document area. Set cancel to discard the edit instead of committing it. Returns the cell address and its text before/after finishing; changed compares those values, including when an edit is cancelled.

• get_area_text(ref*, area=null) Get the text of ONE spreadsheet-document area; omit area to read the current one. tc_doc(action="get_current_area_text") is the older form of this same call and answers identically; prefer this one. (1C 8.3.6+)

• get_current_area_address(ref*) Get the address of the current spreadsheet-document area.

• get_current_area_field(ref*) Get the field of the current spreadsheet-document area. (1C 8.3.2+)

• get_current_area_text(ref*, area=null) Get the text of ONE spreadsheet-document area; omit area to read the current one. This is the older form of tc_doc(action="get_area_text"), which the platform deprecated in 8.3.6 in favour of that one; prefer get_area_text.

• get_doc_area_horizontal_size(ref*) Get the horizontal size (max column number holding data) of a spreadsheet-document. (1C 8.3.13+)

• get_doc_area_vertical_size(ref*) Get the vertical size (max row number holding data) of a spreadsheet-document. (1C 8.3.13+)

• get_formatted_string_hyperlinks(ref*) Get a formatted string's hyperlink presentations. (1C 8.3.25+)

• get_html(ref*) Read the HTML of a formatted/HTML-document field. After the form has put up a menu or a modal choice list, the platform stops returning this field's content until it is written again — an empty answer right after such a window does not mean the field is empty. (1C 8.3.8+)

• included_in_merged_area(ref*, address*) Return the address of the merged area containing the cell (e.g. 'R1C1'), or None if the cell is not part of a merged area. A null answer is ambiguous in one more way: it also comes back when the document has no such cell or no area by that name — the platform does not distinguish the two, and neither can this action. Only the FORM of the address is checked here (cell, range, area name, intersection); whether it exists is up to the document. (1C 8.3.25+)

• input_html(ref*, html*, attachments=null) Set HTML/text into a formatted-document field. attachments maps an image name used in the HTML (e.g. -> "p1") to that image as a base64 string; names must be identifiers (no dots). (1C 8.3.8+)

• read_document(ref*, start_address=null, max_cells=1000) Read nonempty spreadsheet cells as rows with cell addresses and merged-cell spans. Uses the document's data bounds. If complete=false, pass next_address as start_address to continue. max_cells limits positions scanned per call (1–10000).

• set_area_text(ref*, address*, text*) Set a spreadsheet cell's text by address, e.g. R2C1. Selects the cell, starts and finishes editing, then reads the result. Empty text clears it. Returns verified, changed and value_before/value_after. Numeric formatting can return verified=null with verification=numeric_equivalent. Requires an editable document.

• set_current_area(ref*, address*) Set the current area of a spreadsheet-document field (e.g. 'R1C1').

• text_within_area_bounds(ref*, area=null) Whether the text in a spreadsheet-document area fits within its bounds (True) or is clipped to '#####' (False). Pass area (e.g. 'R1C1'); omit to check the current cell. (1C 8.3.25+)

• write_content_to_file(ref*, filename=null, file_format=null, filter_index=null, save_as=null) Save an HTML, formatted, spreadsheet or text document field. PDF fields do not support this action. With filename, Save As is used even for a previously saved document; this call replaces pending file-dialog answers and clears its answer afterwards. For spreadsheets choose file_format: mxl, html, pdf, xls, xlsx, ods or docx. Example: filename="C:/exports/report.xlsx", file_format="xlsx". The extension alone does not select a format. Alternatively filter_index selects a dialog's file type (0-based); do not combine it with file_format. Without either option the dialog's first file type is selected. Without filename, saves under the current name unless save_as=true. If a dialog can appear, prepare it before EACH call using tc_app(action="set_file_dialog_result"). ok confirms that the save request was accepted, not that a file has finished writing. (1C 8.3.8+) connection_id selects the client. Passing ref selects the client automatically; otherwise, with several clients, connection_id is required. Use tc_session(action="list_connections"). Pass reference values returned by the tools unchanged in ref. If a reference expires, find the element again.

Actions on a form field, button, group or element addition. Choose action. Common operations for objects of this type live elsewhere: tc_app(action="get_parent"). In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. ok: true means the client accepted the command, not that anything changed — confirm an effect by reading the state back; target_check: present is not proof of one either. Where the address can be checked the response carries target_check: present, unknown (not checkable here) or off (checking disabled). target_hidden: true appears ONLY when the target exists and was NOT visible; it does NOT prove the absence of an effect — for tc_field(action="activate") invisibility is the normal precondition — it describes the ELEMENT itself and not an invisible container around it, and its absence says nothing. A wrong address is refused with an error only where the address can be checked: a read without a target marker cannot tell one from an empty answer, and tc_table(action="get_cell_text") on a table that does not exist returns text=null exactly as for an empty cell. Actions:

• activate(ref*) Give a form element the focus — this is how you switch to a page or make a table column the current cell; a click does neither. It also commits text left uncommitted by tc_field(action="input_text"), but only when you activate a DIFFERENT focusable element: the field you typed into already has the focus. To let the form choose the next focus target, use tc_form(action="goto_next_element") on the form. Reports no changed — verify with tc_field(action="get_text"), tc_field(action="get_current_page"), tc_form(action="get_current_element") or tc_table(action="get_current_item").

• cancel_edit(ref*) Cancel editing an input field. (1C 8.3.6+)

• choose_from_drop_list(ref*, value*) Pick a value from a field's open drop-down list by its display text (e.g. a colour name) or by its 0-based index in the list. The value is written at once — no focus change is needed. changed may come back null here even when the value did change: with the list open the value cannot be read. Read the field with tc_field(action="get_text") to confirm. (1C 8.3.6+)

• clear(ref*) Clear an input field's value.

• click(ref*) Click a form element (button, cell, etc.). A click PRESSES the element; it does not make it current — clicking a page does not switch to it and clicking a cell does not make it the current cell. Use tc_field(action="activate") for that.

• click_view_status_item(ref*, index*) Click a view-status item by 0-based index (or by its text). Nothing here proves the item was there: the platform answers the same when the form has no view-status line at all, and reading the texts first does not settle it either — that read comes back empty even while a search or filter is active. Judge by the list itself: read the rows before and after. (1C 8.3.16+)

• close_drop_list(ref*) Close a field's drop-down list. Verify with tc_field(action="drop_list_is_open"). (1C 8.3.6+)

• create(ref*) Create a new object from a reference field: opens the new object's form, as the field's '+' does. The field must have the FOCUS first — call tc_field(action="activate") on it, otherwise the command is accepted and nothing opens. Verify by reading the active window. (1C 8.3.6+)

• current_check(ref*) Whether a form BUTTON is pressed, or shows a check mark next to it. Only buttons answer meaningfully: anything else — a checkbox field, a page, a table — always reports false, which means 'not applicable', not 'switched off'. Read a checkbox with tc_field(action="get_text") ('Да'/'Нет') and the active page with tc_field(action="get_current_page"). (1C 8.3.16+)

• current_mode_is_edit(ref*) Whether a table is currently in edit mode. (1C 8.3.3+)

• current_opened(ref*) Whether a form group is currently open. (1C 8.3.16+)

• decrease_value(ref*) Decrement a numeric (spinner) field. A track bar does NOT take this — move it with tc_field(action="goto_value") in percent. When the value does not move, applicable: false in the answer means the method does not fit this kind of field.

• delete_view_status_item(ref*, index*) Delete a view-status item by 0-based index (or by its text) — this is how a filter or a search chip is dropped. Nothing here proves the item was there: the platform answers the same when the form has no view-status line, and reading the texts first does not settle it either. Judge by the list itself: read the rows before and after. (1C 8.3.16+)

• drop_list_is_open(ref*) Whether a field's drop-down list is open. (1C 8.3.6+)

• execute_choice_from_choice_list(ref*, value*) Pick from a field's choice list by its display text or by its 0-based index. Reports changed/value_before/value_after — the field's value read before and after, same as tc_field(action="choose_from_drop_list").

• get_choice_list(ref*) Get a field's choice list. Read it while the drop-down list is OPEN: with the list closed the answer is empty and status is 'unknown', which is normal, not an error. The answer describes the list that is currently OPEN, not the element you addressed — with one field list open, any other field ref returns that same list with status='ok'. Open the list on the field you are asking about (tc_field(action="open_drop_list")) and read it immediately. 'items' holds {presentation, text} per entry; 'presentations' is just their texts, which is exactly what tc_field(action="choose_from_drop_list") accepts. (1C 8.3.12+)

• get_command_bar(ref*) Get an element's own command panel object, if it has one. This is NOT the list of buttons: the panel is a container, and its buttons are read with a separate tc_app(action="get_child_objects") on the returned ref. An empty result means the element has no command panel of its own — a list table is the usual case, its buttons live in a form group next to it. (1C 8.3.3+)

• get_context_menu(ref*) Get an element's context menu. The platform returns the menu as a form GROUP, not as a list of commands: 'menu' holds that group, and its items are read with a separate tc_app(action="get_child_objects") on the group's ref. (1C 8.3.3+)

• get_current_page(ref*) Get the current page of a page group. To switch pages use tc_field(action="activate"): a click on a page does not switch to it. tc_field(action="current_check") is useless here — pages always report checked=false. (1C 8.3.6+)

• get_data_presentation(ref*) Get an element's data presentation. Form fields only — not form decorations, and on a table the answer is always null. An empty input field returns "". presentation is null when no value was available; that is not proof that the field has no presentation.

• get_edit_text(ref*) Read an input field's edit buffer — what is being typed, which is not necessarily what the form holds. get_data_presentation reads the accepted value; get_text reads displayed text. An empty input buffer returns ""; null means unavailable. (1C 8.3.3+)

• get_linked_window(ref*) Get the linked window of a command-interface button. An empty answer means the button has no linked window — but only when target_check says the button itself is there; a wrong ref answers empty too, and the check is what tells the two apart. (1C 8.3.6+)

• get_state_presentation(ref*) Read a form field's state presentation. An unavailable value is explained in the answer; null does not confirm that the field has no state presentation. (1C 8.3.16+)

• get_text(ref*) Read displayed text (checkbox text follows the client language). An empty input field returns "". For an edit buffer use get_edit_text. If text is unavailable, the answer explains the limitation and suggests another reading action where applicable. null does not confirm an empty field. (1C 8.3.12+)

• get_tooltip(ref*) Read an element's tooltip text (empty → None). (1C 8.3.3+)

• get_view_status_item_texts(ref*) Get the view-status item texts of a form-element addition → list of strings. Do not use it to tell whether a filter or search is active: with a list narrowed down to one row by search the platform still answers with an empty collection. Check the effect by reading the rows. (1C 8.3.16+)

• goto_value(ref*, percent*) Move a TRACK BAR to a value in PERCENT (0..100). This is a track bar method: on any other kind of field the command is accepted and nothing moves, and the answer then carries applicable: false. A spinner is stepped with increase_value/decrease_value instead. Returns changed/value_before/value_after. (1C 8.3.6+)

• increase_value(ref*) Increment a numeric (spinner) field. A track bar does NOT take this — move it with tc_field(action="goto_value") in percent. When the value does not move, applicable: false in the answer means the method does not fit this kind of field.

• input_text(ref*, text*, finish=True) Enter text. Ordinary form input fields finish automatically: the owning form moves focus once to its next element, then the accepted value is checked. finish=false leaves the editing buffer active, for example before choosing a reference suggestion or cancelling. Empty text clears the value directly. Reference input can still need a matching value. committed=true confirms the accepted text; false means pending; null means unverified. edit_finished reports whether focus left the ordinary field. Numeric formatting can produce verification=numeric_equivalent with committed=null. changed compares displayed text. These flags do not mean the record was saved. Table cells use tc_table(action="set_cell_text"). Text documents finish by activating another element with tc_field(action="activate"); spreadsheet cells use tc_doc(action="end_edit_current_area").

• is_enabled(ref*) Whether an element is currently enabled. (1C 8.3.3+)

• is_readonly(ref*) Whether an element is currently read-only — that is the element's own read-only property. Two other things look the same and are NOT this: an element switched off entirely (read that with tc_field(action="is_enabled")), and a spreadsheet-document field shown in view mode, which neither read reflects — there, tc_doc(action="begin_edit_current_area") runs the cell's details instead of editing. (1C 8.3.3+)

• is_visible(ref*) Whether an element is currently visible. Returns an error instead of visible=false when there is no object at ref: for this read the protocol does report a missing target, so a mistyped address cannot pass for a hidden element. On the pages of a page group this does NOT tell you which page is on screen — several pages report visible=true at once; use tc_field(action="get_current_page") for that. (1C 8.3.3+)

• open_drop_list(ref*) Open the drop-down list of a reference/enum field (call before choose_from_drop_list). (1C 8.3.6+)

• open_field(ref*) Open a reference field's value (F4 / follow the link).

• select_option(ref*, value*) Pick a radio-button option by its display text or by its 0-based index.

• set_check(ref*) Toggle a checkbox field. Inside a table this acts on the column that is the CURRENT cell, so make the target column current first — tc_field(action="activate") on the column element does that; a click on the cell does not.

• start_choosing(ref*) Open a reference field's choice form. Handles focus and table-cell editing. Returns opened and the active window; use that window to continue choosing.

• start_choosing_from_choice_list(ref*) Start choosing from a field's choice list.

• title_is_shown(ref*) Whether an element's title is shown. (1C 8.3.25+)

• wait_for_drop_list_generation(ref*, timeout=60) Wait up to timeout seconds for a drop-down list to be generated. Returns generated=True if a list appeared within the timeout, else False. The answer is not tied to the element you addressed — it can come back true before this field's list is open at all, the same way get_choice_list describes. Open the list on the field you care about first (tc_field(action="open_drop_list")) and read it right after. (1C 8.3.4+) connection_id selects the client. Passing ref selects the client automatically; otherwise, with several clients, connection_id is required. Use tc_session(action="list_connections"). Pass reference values returned by the tools unchanged in ref. If a reference expires, find the element again.

Search the UI tree for objects. In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. Actions:

• find_object(name=null, cls=null, type=null, root_ref=null, title=null, timeout=0) Find the first object matching the criteria (parameters as in tc_find(action="find_objects")). When nothing matched, the answer carries the same filter diagnostics as tc_find(action="find_objects"). (1C 8.3.3+)

• find_objects(name=null, cls=null, type=null, root_ref=null, title=null, timeout=0) Find all objects in the UI tree matching the criteria. name and title take the wildcards * and ?; cls is the class and type is the platform's element kind (both as reported by tc_app(action="get_child_objects"), e.g. CheckBoxField or Popup); root_ref is where to start (default: the active window); timeout keeps retrying for that many seconds while nothing matches (0 = a single pass). An empty result is not an error, so ok stays true. When nothing matched and a cls or type was given, the answer also says whether the server knows that filter and what was actually present, so a misspelling is distinguishable from an object that never appeared. (1C 8.3.3+)

• wait_for_object_displayed(name=null, cls=null, type=null, title=null, timeout=60) Poll the UI tree until an object matching the criteria appears, up to timeout seconds. Returns the object, or ok=False on timeout. Criteria as in tc_find(action="find_objects"). On timeout the answer says whether a cls was seen at all and lists the classes that were actually present, so a misspelled class name is distinguishable from an object that never appeared. (1C 8.3.3+) connection_id selects the client. Passing root_ref selects the client automatically; otherwise, with several clients, connection_id is required. Use tc_session(action="list_connections"). Pass reference values returned by the tools unchanged in root_ref. If a reference expires, find the element again.

Actions on the managed form itself, including navigation between form elements and reading the focused element. Choose action. Common operations for objects of this type live elsewhere: tc_field(action="is_visible"), tc_field(action="is_enabled"), tc_field(action="get_context_menu"), tc_app(action="get_parent"). In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. ok: true means the client accepted the command, not that anything changed — confirm an effect by reading the state back; target_check: present is not proof of one either. Where the address can be checked the response carries target_check: present, unknown (not checkable here) or off (checking disabled). target_hidden: true appears ONLY when the target exists and was NOT visible; it does NOT prove the absence of an effect — for tc_field(action="activate") invisibility is the normal precondition — it describes the ELEMENT itself and not an invisible container around it, and its absence says nothing. A wrong address is refused with an error only where the address can be checked: a read without a target marker cannot tell one from an empty answer, and tc_table(action="get_cell_text") on a table that does not exist returns text=null exactly as for an empty cell. Actions:

• current_modified(ref*) Whether a form has been modified. (1C 8.3.3+)

• execute_choice_from_list(ref*, index*) Pick an item from a modal choice list by 0-based index or display text. Not a field's drop-down (use tc_field(action="choose_from_drop_list")). ref: the form (ManagedForm), not a field. (1C 8.3.8+)

• execute_choice_from_menu(ref*, index*) Pick an item from an OPEN menu by 0-based index or display text; nested submenus are not supported. This works for a menu the form put up, and for the menu a spreadsheet document raises over a cell that has DETAILS — address the form or the field, either reaches the menu that is open. It selects from a menu that is ALREADY open: if none is, nothing happens. On a spreadsheet-document field this needs platform 8.3.25 or newer. (1C 8.3.8+)

• find_default_button(ref*) Find the form's default button. ref is the form's ref. (1C 8.3.3+)

• get_current_element(ref*) Get the managed form's focused element as item: [{ref}]. ref: the form (ManagedForm). The platform can return no current element after navigating out of its fields.

• goto_next_element(ref*) Move focus to the next element in the managed form's tab order. ref: the form (ManagedForm). This can finish the current field's pending input; read the field's data presentation to verify acceptance. Reference fields may still require choosing a value.

• goto_previous_element(ref*) Move focus to the previous element in the managed form's tab order. ref: the form (ManagedForm). This can finish the current field's pending input; read the field's data presentation to verify acceptance.

• wait_for_closing(window_title=null, timeout=60) Wait until a window closes, up to timeout seconds. Without window_title it watches the window that is active AT THE MOMENT OF THE CALL, so it only makes sense BEFORE the action that closes something; called after tc_window(action="close_window") it is already watching the next window and will time out while reporting the window is still open. After a close, pass window_title — the title is taken from the window's managed form, and if it cannot be determined the call says so instead of claiming the window closed. (1C 8.3.3+) connection_id selects the client. Passing ref selects the client automatically; otherwise, with several clients, connection_id is required. Use tc_session(action="list_connections"). Pass reference values returned by the tools unchanged in ref. If a reference expires, find the element again.

Record and replay UI scenarios. In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. Actions:

• record_cancel() Cancel user-actions recording (discard the scenario). (1C 8.3.2+)

• record_finish(path=null) Stop recording and return the scenario XML in 'uilog', or write it to path, resolved against the SERVER working directory and echoed back absolute. If the file cannot be written the answer carries ok=false, the path, the reason AND the scenario in 'uilog' — recording is already stopped, so a second call will not give it back. lost_actions: actions that could not be captured, so the scenario is incomplete for replay. no_effect: calls whose value came back unchanged — a hint to check, not a verdict, and it numbers CALLS, not steps of the XML. observed/not_observed count the calls whose result could and could not be read back; readback/scope say whether reading back was on at all and how wide it reached. An empty no_effect with zero observed means nothing was checked. (1C 8.3.2+)

• record_pause() Pause user-actions recording: actions performed until tc_scenario(action="record_resume") stay out of the scenario. (1C 8.3.2+)

• record_resume() Resume user-actions recording. (1C 8.3.2+)

• record_start() Start recording a scenario (uilog) that tc_scenario(action="run_scenario") can replay later. Perform the real, effect-producing actions between start and tc_scenario(action="record_finish"), then read the scenario from finish. (1C 8.3.2+)

• run_scenario(uilog=null, path=null) Replay a recorded uilog scenario on the current form. Give the XML in uilog or a path to a file with it. Steps that could not be replayed are listed in unsupported. total counts every step in the scenario; played counts the ones actually attempted, REGARDLESS of how they went, so a failed step is still counted. Neither is a count of effects: ok says every attempted step was accepted, and the effect of a step is in steps[].changed, the same contract as when you call the action directly. connection_id selects the client. With several clients, connection_id is required. Use tc_session(action="list_connections").

Connect to, launch or stop the 1C test client. In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. Actions:

• connect(port*, host='127.0.0.1', version=null) Connect to a running 1C test client (started with /TESTCLIENT -TPort ). version is the platform version (e.g. '8.5.1.1343') and MUST match the running platform, else the handshake fails; if omitted a built-in default is used. Call this before any other tc_* tool. A different host/port creates another connection. The same host/port reconnects that client; its connection_id is retained, but find elements again before using them.

• disconnect() Close the connection to the test client.

• launch_client(base*, port=null, server=False, user=null, password=null, version=null, exe=null, extra_args=null, wait=30, connect=True) Launch a 1C test client and wait until it accepts connections on port, then optionally connect to it. base is a file infobase path (default), or 'server\infobase' when server=True. user/password — infobase credentials (optional; the password is passed on the command line and is visible in the OS process list). exe — full path to 1cv8.exe on Windows, or 1cv8/1cv8c on Linux (else env TC1C_PLATFORM_EXE or standard install path). Only the 1C platform executable is launched. Omit port to allocate a free local port. Each launch creates a separate connection_id. Linux requires access to a graphical session via the server's DISPLAY/XAUTHORITY environment. With connect=false ok means only that the port answers — the client can be up and showing an error, so check it before relying on it.

• list_connections() List registered clients with connection_id, host, port, base, user and recording status. base/user are known for clients launched here; listing does not probe client health.

• stop_client() Stop the test client started by launch_client in this connection, and disconnect from it. Unsaved changes may be lost. If stopping fails, retain the process so the call can be retried. connection_id selects the client. With several clients, connection_id is required. Use tc_session(action="list_connections").

Read and edit table or tree rows, manage selection and expand or collapse nodes. Choose action. Common operations for objects of this type live elsewhere: tc_field(action="is_visible"), tc_field(action="is_enabled"), tc_field(action="get_context_menu"), tc_app(action="get_parent"). In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. ok: true means the client accepted the command, not that anything changed — confirm an effect by reading the state back; target_check: present is not proof of one either. Where the address can be checked the response carries target_check: present, unknown (not checkable here) or off (checking disabled). target_hidden: true appears ONLY when the target exists and was NOT visible; it does NOT prove the absence of an effect — for tc_field(action="activate") invisibility is the normal precondition — it describes the ELEMENT itself and not an invisible container around it, and its absence says nothing. A wrong address is refused with an error only where the address can be checked: a read without a target marker cannot tell one from an empty answer, and tc_table(action="get_cell_text") on a table that does not exist returns text=null exactly as for an empty cell. Actions:

• can_be_expanded(ref*, row_column=null, row_value=null) Whether a table row/group can be expanded. Pass row_column+row_value to target a specific row by a column name or title; omit them to use the current row. can_expand=true does not promise that tc_table(action="expand") will work: rows reporting true have been observed to stay collapsed. The reliable evidence is tc_table(action="expand")'s own value_before/value_after pair.

• change_row(ref*) Start editing the current table row/column. Needs an existing row not already in edit mode.

• choose_row(ref*) Choose (select / double-click) the current table row. In a choice form this picks the row and closes the form; in a list form the same action OPENS the row's item — on a hierarchical list, the folder own card rather than stepping into the folder. changed reports whether the ACTIVE WINDOW changed: true means a window opened or closed, which is what a completed choice looks like; false means the window stayed — the choice did not go through, or the row was picked without closing anything, so read the field you were filling to tell those apart.

• collapse(ref*, row_column=null, row_value=null) Collapse a form group (Group[...]) or a table node. For a table, pass row_column+row_value to target a row by a column name or title; omit them for the current row. Nothing to collapse is not an error: ok only reports that the client accepted the command. changed is false only when value_before and value_after were both read and came back equal, which happens for a TABLE node, and null when they could not be read — a FORM GROUP (the platform's Expanded applies to tables only), a failed read, or readback='off'. can_be_expanded checks a table row, not a form group, and its true is not a promise: judge by value_before/value_after.

• copy_row(ref*, confirm=null) Copy the current table row. On catalog/document lists a confirmation dialog may appear — set confirm=True/False to auto-answer it (default None: no dialog handling). (1C 8.3.25+)

• delete_row(ref*, confirm=null) Delete the current table row. On catalog/document lists a 'delete?' dialog may appear — set confirm=True/False to auto-answer it (default None: no dialog handling). (1C 8.3.3+)

• deselect_all_rows(ref*) Clear the table's row selection. Needs platform 8.5.1 or newer — on every earlier one the platform has no such method. Plain row navigation drops the selection down to the current row, which is the only way to undo a multi-row selection there. (1C 8.5.1+)

• deselect_row(ref*) Remove the current table row from the selection. Needs platform 8.5.1 or newer — on every earlier one the platform has no such method. The closest thing there is to pass over the row with toggle_selection set: that toggles it, so a selected row becomes unselected. (1C 8.5.1+)

• end_edit_row(ref*, cancel=False) Finish editing the current table row. Set cancel to discard the edits instead of committing them.

• expand(ref*, row_column=null, row_value=null, subordinates=False) Expand a form group (Group[...]) or a table node. For a table, pass row_column+row_value to target a row by a column name or title; omit them for the current row. Set subordinates to also expand the child rows. Nothing to expand is not an error: ok only reports that the client accepted the command. changed is false only when value_before and value_after were both read and came back equal, which happens for a TABLE node, and null when they could not be read — a FORM GROUP (the platform's Expanded applies to tables only), a failed read, or readback='off'. can_be_expanded checks a table row, not a form group, and its true is not a promise: judge by value_before/value_after.

• get_cell_text(ref*, column*) Read a cell in the current row. Text may include search-highlight markup. column is the column element NAME, or its 0-based index as a number or a string of digits ('0' is index 0, not a name — an element name cannot start with a digit). Unknown or ambiguous column names are refused; a matching title suggests the element name. Only displayed columns can be read. null does not establish that the cell is empty. A column inside a COLUMN GROUP that the table shows as one column may answer with the GROUP's text — a neighbouring column's value — and that answer cannot be told from a correct one; members of other kinds in the same group answer null instead.

• get_current_item(ref*) Get the current item of a table → {ref}. ref: the table.

• get_current_row(ref*) Get the current table row as [{column: value}]. Returns [] if there is no current row or its values could not be read. Needs platform 8.5.1 or newer — on every earlier one, use get_selected_rows after moving to the desired row, or get_cell_text to read one column. (1C 8.5.1+)

• get_selected_rows(ref*) Get the selected table rows as a list of {column: value} maps, one per selected row, in LIST order — the current row is NOT put first, so do not read rows[0] as "the first row of the list". The keys are column TITLES; the column titled "Вид" can be EditField[ЮрФизЛицо], so match by title, not by name. Which columns a row carries is decided by the platform: a column missing from the answer does not mean the row has no value there, and an empty string is ambiguous — it can be a value the platform sent as empty or a filler for a column it did not send. Values may include search-highlight markup. (1C 8.3.6+)

• go_one_level_down(ref*, row_column=null, row_value=null, column=null) Go one level down in a table tree. Pass row_column+row_value to target a specific row by a column value; row_column accepts a column name or title. Omit both to use the current row. Optional column names a column to read before and after the move; changed compares its cell text.

• go_one_level_up(ref*, row_column=null, row_value=null, column=null) Go one level up in a table tree. Pass row_column+row_value to target a specific row by a column value; row_column accepts a column name or title. Omit both to use the current row. Optional column names a column to read before and after the move; changed compares its cell text.

• goto_first_row(ref*, toggle_selection=False, column=null) Move to the first row of a table. Set toggle_selection to also toggle that row's selection. Pass column (the column element NAME) to have that cell read before and after the move: it comes back as value_before/value_after with changed=true when they differ. changed=false only means the two texts are the same — different rows can share a value; without column nothing is read and changed is null.

• goto_last_row(ref*, toggle_selection=False, column=null) Move to the last row of a table. Set toggle_selection to also toggle that row's selection. Pass column (the column element NAME) to have that cell read before and after the move: it comes back as value_before/value_after with changed=true when they differ. changed=false only means the two texts are the same — different rows can share a value; without column nothing is read and changed is null.

• goto_next_item(ref*) Move to the next item within a table. ref: the table.

• goto_next_row(ref*, toggle_selection=False, column=null) Move to the next row of a table. Set toggle_selection to also toggle that row's selection. Pass column (the column element NAME) to have that cell read before and after the move: it comes back as value_before/value_after with changed=true when they differ. changed=false only means the two texts are the same — different rows can share a value; without column nothing is read and changed is null.

• goto_previous_item(ref*) Move to the previous item within a table. ref: the table.

• goto_previous_row(ref*, toggle_selection=False, column=null) Move to the previous row of a table. Set toggle_selection to also toggle that row's selection. Pass column (the column element NAME) to have that cell read before and after the move: it comes back as value_before/value_after with changed=true when they differ. changed=false only means the two texts are the same — different rows can share a value; without column nothing is read and changed is null.

• goto_row(ref*, column=null, value=null, direction='down', toggle_selection=False, fields=null) Go to the table row where column equals value (int or string; the wildcards * and ? work). column is the column TITLE; an index is not accepted here. Pass fields ({column: value}) to match several columns at once. Seeks directly, so there is no need to walk rows. Matching is CASE-SENSITIVE and compares the value as SHOWN ("Встреча агента (Совещание)"), so a wildcard is often what you want. The search starts at the CURRENT row, runs in direction (down by default, or up) to the end of the list and does NOT wrap; the current row is itself a candidate, so searching for the value the cursor already sits on reports found=true without moving — step off the row first to find the NEXT match. A search that finds nothing still MOVES the cursor, to the last row going down, the first going up. Set toggle_selection to toggle the row it lands on; with no column and no fields it just toggles the current row. found is null when there was nothing to search for or the search result could not be determined — null never means "not found". In the answer criteria repeats the TITLE you searched by and observed.column gives that same column NAME. (1C 8.3.2+)

• is_expanded(ref*, row_column=null, row_value=null) Whether a table row is expanded. Without row_column this reads the CURRENT row. Pass row_column (column name or title) and row_value to read another row without moving the cursor.

• select_all_rows(ref*) Select all rows of a table. (1C 8.3.6+)

• select_row(ref*) Add the current table row to the selection. Needs platform 8.5.1 or newer — on every earlier one the platform has no such method. Build a selection there by moving through rows with toggle_selection set — each row the cursor passes is toggled. (1C 8.5.1+)

• set_cell_text(ref*, column*, text*) Set text in the current row's column (element name). Handles focus and row editing, then reads the result. Empty text clears the cell. Returns verified, changed and value_before/value_after. Numeric formatting can return verified=null with verification=numeric_equivalent. Continues an existing row edit, including a newly added row, and finishes it without discarding other cells' edits.

• set_order(ref*, column*) Sort a table by a column, addressed by its TITLE. There is no direction parameter and no way to read the current direction: calling it again on the same column reverses the order. To learn which way it went, go to the first row and read a cell. (1C 8.3.6+)

• switch_row_delete_mark(ref*, confirm=True) Toggle the deletion mark of the current row. Raises a modal 'mark for deletion?' dialog that is auto-answered: confirm=True → Yes (default), False → No. dialog_answered only reports that a modal question was answered — it is NOT evidence that the mark changed, and changed is always null here because the platform exposes no readable deletion-mark flag. To check the result, click the row's mark command and read the question text: 'mark for deletion?' means it is not marked, 'remove the mark?' means it is. (1C 8.3.6+)

• table_add_row(ref*) Add a row to a form table. Fill its cells with set_cell_text using column element names. connection_id selects the client. Passing ref selects the client automatically; otherwise, with several clients, connection_id is required. Use tc_session(action="list_connections"). Pass reference values returned by the tools unchanged in ref. If a reference expires, find the element again.

Actions on the client application window. In the signatures below a trailing * marks a REQUIRED parameter — the group schema itself accepts every parameter as optional. Actions:

• activate_window() Activate the current active window. (1C 8.3.3+)

• answer_dialog(confirm=True, timeout=5) Answer a modal Yes/No question raised by the configuration. The question is an ordinary window and its buttons are picked by NAME: Button0 answers yes, Button1 answers no. A dialog may offer a THIRD choice (Button2 is often 'Отмена') which this action never presses — read question and inspect the window with tc_find(action="find_objects") when the answer you need is a different button. Waits up to timeout seconds for such a dialog to appear. Returns answered='Да'/'Нет' and question, or both null when no dialog showed up; question alone is null when the dialog carried no readable message. (1C 8.3.3+)

• close_user_messages_panel() Close the window's user-messages panel. This is also how you tell which messages belong to which action: clear the panel, perform the action, then read the messages. (1C 8.3.6+)

• close_window() Close the current active window. ok only says the close was accepted: the configuration may answer with a modal question ('Send the invitations?', 'Save the changes?') and leave the window open. Check with get_active_window afterwards. Also closes an active local print preview identified by get_active_window, returning to the underlying form. If the active window cannot be identified and local recovery is unavailable, returns code=active_window_unavailable without closing another window. (1C 8.3.3+)

• execute_command(command*) Run a window command by name, or open an object by a navigation link. Both forms are accepted: a command-interface command name, and a link such as 'e1cib/list/Справочник.Контрагенты' (list), 'e1cib/app/Обработка.Имя' or 'e1cib/command/...'. The navigation link is usually how a scenario starts, since it opens a list or form without hunting through the command interface first. (1C 8.3.3+)

• get_command_interface() Get the window's command interface → collection of buttons/groups. (1C 8.3.3+)

• get_user_message_texts() Get the user-message texts shown in the window → list of strings. These ACCUMULATE over the session: a complaint from an earlier attempt is still listed after a later attempt succeeded. To judge one action, call tc_window(action="close_user_messages_panel") first, then the action, then this. (1C 8.3.3+)

• goto_next_window() Ask for the next application window. The command is accepted, but no measurement has shown it switching anything: the platform runs it on the MAIN application window only, and that window is not addressable here. To go to another window, activate its form — tc_field(action="activate") on that window's ManagedForm ref, measured to work both ways. (1C 8.3.6+)

• goto_previous_window() Ask for the previous application window. The command is accepted, but no measurement has shown it switching anything: the platform runs it on the MAIN application window only, and that window is not addressable here. To go to another window, activate its form — tc_field(action="activate") on that window's ManagedForm ref, measured to work both ways. (1C 8.3.6+)

• goto_start_page() Ask for the start page. The command is accepted, but no measurement has shown it switching anything: the platform runs it on the MAIN application window only, and that window is not addressable here. To go to another window, activate its form — tc_field(action="activate") on that window's ManagedForm ref, measured to work both ways. (1C 8.3.6+) connection_id selects the client. With several clients, connection_id is required. Use tc_session(action="list_connections"). Returned references can be passed unchanged to actions that accept them. If a reference expires, find the element again.