Checks the connection: lists running Archicad instances (port, version, build, language), which one is active, and whether the Claude Connector add-on (full create/modify power) and Tapir add-on are available. Call this first if anything fails.

When several Archicad instances run, switches all following tool calls to the instance listening on port (see archicad_status).

Returns the full usage guide for this connector: units, coordinate system, element references, workflows (building a model, documentation, schedules), gotchas (localized library names, top-linked walls, undo), and which tool to use for what. Read it before complex tasks.

Lists every JSON command implemented by the Claude Connector add-on (namespace ClaudeConnector) with descriptions. Useful together with execute_addon_command for features without a dedicated tool.

Escape hatch: runs any official Archicad JSON API command verbatim, e.g. command 'API.GetNavigatorItemTree' with parameters {navigatorTreeId: {type: 'ProjectMap'}}. Prefer the dedicated tools; use this for commands without one. Reference: https://archicadapi.graphisoft.com/JSONInterfaceDocumentation/

Escape hatch: runs any add-on JSON command through API.ExecuteAddOnCommand. Default namespace is 'ClaudeConnector' (see list_addon_commands); other installed add-ons also work, e.g. namespace 'TapirCommand'.

Creates elements of ANY supported type in one undo step. Each item is {type: 'Wall'|'Column'|'Beam'|'Slab'|'Roof'|'Shell'|'Mesh'|'Zone'|'Window'|'Door'|'Skylight'|'Opening'|'Object'|'Lamp'|'Line'|'Arc'|'Circle'|'PolyLine'|'Spline'|'Hatch'|'Text'|'Label'|'Dimension'|'LevelDimension'|'Hotspot'|'Morph'|'CurtainWall'|..., ...fields}. The fields are the same as in the type-specific create_* tools (prefer those: they document every field). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others.

Returns everything known about elements: common fields (guid, type, storyIndex, layer, elementId, group/hotlink, renovation status, lock) plus type-specific details (geometry, heights, structure/materials, library part & key params, relations such as the openings of a wall). Works for all element types.

Changes fields of existing elements in one undo step. Each item is {guid, ...fields to change}; the field names are the same as the type's create_* tool (e.g. a wall: height, thickness, begin, end, composite; any element: layer, storyIndex, renovationStatus, elementId). Only the given fields change. Returns [{guid} | {error}].

Lists every Archicad element type and whether this connector can create it, read its details, and modify it.

Creates straight, curved, trapezoid or slanted walls (one undo step). Coordinates in meters, angles in degrees, on the given story (default: current story). Unspecified settings come from the Wall tool defaults. Chain walls end-to-start so Archicad joins the corners. Returns [{guid, type} | {error}] in input order.

Returns facts about the open project and Archicad: projectName, untitled (never saved), file {path, fileName, folder, fileType (SoloProject/Archive/Template...), exists, writable}, teamwork + teamworkInfo, current window/database (type, name) and current story (index, name, level), application {mainVersion, buildNumber, language, jsonApiPort...}, special folders (temporary, templates, userDocuments, application, projectTemporary...). Pass includeTemplates: true to also list installed .tpl templates (for new_project). Call this before save/open/new/close operations.

Lists the Project Info fields (File > Info > Project Info), i.e. the project autotexts used in title blocks and layouts: [{name (localized UI label, e.g. Russian), key (database key such as 'PROJECTNAME', 'CLIENT', 'autotext-' for custom fields), value, category}]. Categories: Fixed = built-in project fields, Custom = user-added fields, Other = values computed by Archicad (dates, layout/drawing data; usually not settable). Use the key with set_project_info_fields.

Sets Project Info field values (shown by autotexts in title blocks/stamps). Identify each field by its database key (preferred; from get_project_info_fields) or by its exact localized name. createIfMissing: true adds a CUSTOM field for names that do not exist. Returns per-item results [{name, key, value, category, created?} | {error}]. Delete custom fields with delete_project_info_fields.

Deletes CUSTOM Project Info fields (category Custom) by database key or name. Built-in fields cannot be deleted (set their value to "" instead). Returns [{key, deleted} | {error}].

Saves the open project to its own file (File > Save). Fails for untitled (never saved) projects — use save_project_as — and for read-only projects. Returns {saved, project}.

Saves the project under a new file (File > Save As). Afterwards the open project refers to the NEW file. Formats: pln (solo project), pla (archive incl. library parts), tpl (template), pln25/pla25 (Archicad 25 = previous version). The format defaults to the path extension; a missing extension is added. For IFC/DWG/PDF/image exports use the export tools instead. Returns {saved, format, file, project}.

Opens a project file (.pln, .pla archive, .tpl template → untitled project, .bpn backup), CLOSING the current project. You must decide about unsaved changes: saveFirst: true or discardChanges: true. BIMcloud/Teamwork projects cannot be opened by path. Opening can take minutes and Archicad may show dialogs (e.g. missing libraries). Returns {opened, project}.

Creates a new untitled project, CLOSING the current one: from a template (.tpl path — list installed ones with get_project_info {includeTemplates: true}) or with File > New (reset: true = New & Reset, i.e. default settings). You must decide about unsaved changes: saveFirst: true or discardChanges: true. Returns {created, project}.

Closes the current project. WARNING: the Archicad JSON API only listens while a project is open, so after this NO tool works until a project is opened by hand in Archicad. Prefer open_project/new_project to switch projects. Requires confirm: true and saveFirst or discardChanges.

Quits Archicad. Without saveFirst: true, unsaved changes are DISCARDED. After quitting no tool works until Archicad is started again. Requires confirm: true.

Reads Project Preferences: workingUnits, dimensions (display formats per dimension type), calculationUnits, calculationRules, referenceLevels, legacy, zones, imagingAndCalculation, floorPlanCutPlane, layouts, dataSafety (temporary folder) and environment switches (autoIntersect, autoGroup, suspendGroups, autoTextEnabled, exportTolerance). Units shown here only affect display; the connector always uses meters/degrees. Field names are the ones set_preferences accepts.

Changes Project Preferences (only the given sections/fields; read the current values with get_preferences first). Examples: {workingUnits: {lengthUnit: 'Millimeter', lengthDecimals: 0}}, {dimensions: {linear: {unit: 'Centimeter', decimals: 1}}}, {floorPlanCutPlane: {cutHeight: 1.2}}, {environment: {autoIntersect: false}}. Returns per-section {ok, value} | {error}. dataSafety is read-only. In Teamwork, Project Preferences must be reserved.

Returns the project location: latitude/longitude (degrees), altitude (m), northDirection (degrees, CCW from the +X axis; 90 = north points to +Y/up on the plan), timeZoneMinutes, summerTime, dateTime and sun {azimuth, altitude} used for sun studies, surveyPoint {position (project coordinates, m), visible, locked, projectOriginInSurveyCoordinates}, geoReference (IFC CRS / map conversion: eastings, northings, orthogonalHeight...) and editable.

Changes the project location (Options > Project Preferences > Location / Survey Point). Give only the fields to change. Changing northDirection or the survey point needs an unlocked Survey Point (pass unlockSurveyPoint: true to unlock temporarily). Date/location changes also recompute the sun position. Returns the new location (as get_geo_location).

Refreshes the current (front) window: 'Rebuild' (default, View > Refresh > Rebuild), 'Regenerate' (Rebuild & Regenerate: recomputes all element geometry — use after library/parameter changes or when the display looks stale) or 'Redraw' (repaint only).

Undos the last Archicad operation(s), exactly like Edit > Undo. Every connector create/modify tool call is ONE undo step (its name ends with '(Claude)'), so steps: 1 reverts one whole tool call. The Archicad 26 API has no undo function: this triggers Archicad's Edit menu item (macOS). Returns {performed, requested, undone (menu titles, e.g. 'Undo Create walls (Claude)'), next}. dryRun: true only reports what would be undone next. Note: undo also reverts changes made by the user or other tools.

Redos the last undone Archicad operation(s), exactly like Edit > Redo. Every connector create/modify tool call is ONE undo step (its name ends with '(Claude)'), so steps: 1 reverts one whole tool call. The Archicad 26 API has no redo function: this triggers Archicad's Edit menu item (macOS). Returns {performed, requested, redone (menu titles, e.g. 'Redo Create walls (Claude)'), next}. dryRun: true only reports what would be redone next. Note: undo also reverts changes made by the user or other tools.

Lists all stories (floors) of the project, bottom to top: {stories: [{index, displayNumber, name, level (m above Project Zero), height (m to the next story; may be missing for the top story), floorId (stable id), showOnSections, isCurrent, reservedByOtherUser (Teamwork, only when true)}], firstIndex, lastIndex, currentIndex, count, skipNullFloor, ghostStory}. Call this first for any story-related work: element tools place elements by storyIndex (elevations are relative to the home story), and story names are localized. displayNumber is the number shown in the Navigator: when skipNullFloor is true (e.g. the Russian template) index 0 is shown as '1.', so 'the 3rd floor' is displayNumber 3 = index 2 — always pass the index (or name) to other tools. Indexes change when stories are inserted/deleted; floorId does not. Use atLevels to convert absolute elevations to {storyIndex, offsetFromStory}, and includeElementCounts to see what is on each story.

Inserts new stories (Story Settings > Insert Above/Below). Items are applied in order, each one seeing the stories created by the previous items, so several 'Top' items stack upwards. Default: a new top story with the height of the current top story. height is the height of the NEW story; level only (Above/Below) fills the gap between two stories without moving anything. Inserting shifts the indexes of the stories above (floorId stays stable) — re-read indexes from the returned 'stories' before using them. Returns {results: [{story, movedStories?: [{floorId, index, name, levelBefore, level}]} | {error}] in input order, stories: [all stories after the change]}. Story changes are applied immediately (not via Archicad's undo); a failed item is reverted by the add-on. Example: {stories: [{name: 'Этаж 4', height: 3}, {name: 'Кровля', height: 2.5}]}.

Changes existing stories, patches applied in order: rename, change level (elevation above Project Zero; only this story moves unless moveStoriesAbove), change height to the next story (the stories above move), toggle 'show on sections'. Only the given fields change. Elements keep their position relative to their home story, so changing levels/heights moves them vertically (and changes the height of walls/columns linked to a moved story). Returns {results: [{story, movedStories?} | {error}], stories: [all stories after the change]}; a failed patch is reverted.

Deletes stories AND EVERY ELEMENT whose home story they are. Use ONLY when the user explicitly asks to delete stories. Run with dryRun: true first to see how many elements each story holds. All references are resolved before anything is deleted (so [2, 3] means the current stories 2 and 3); at least one story must remain. Indexes of the remaining stories shift. By default Archicad closes the gap (the stories above a deleted story move down); keepLevels: true keeps every remaining story at its elevation instead (the story below a deleted one gets taller). Returns {results: [{deleted: story+elementCount} | {error}], movedStories?, stories: [remaining], warning?} or, with dryRun, {dryRun, wouldDelete, remainingCount}.

Makes a story the current one and (by default) shows its floor plan, like double-clicking the story in the Navigator. New elements are placed on the current story when no storyIndex is given, and floor plan screenshots/zooms show it. Returns {currentStory, windowChanged}.

Lists Archicad attributes of one type with their settings: {index, name, guid, folder?, ...type fields} using the SAME field names that the create_*/modify_attributes tools accept. Summary fields per type — Layer: hidden, locked, wireframe, intersectionGroup; Pen: color, width (mm); Line: lineType, scaleWithPlan, period; Fill: fillType, usage, bitmapPattern, spacingX/Y (pattern units × spacingX = meters), percent; Composite: totalThickness, skinCount, usage; Surface: color, transparency, reflection, fill, texture; LayerCombination: active, layerCount; ZoneCategory: code, color, stamp; BuildingMaterial: cutFill, pens, surface, uiPriority (0-999 as in the UI), thermal properties; Profile: usage; PenTable: activeForModel/Layout; MEPSystem, OperationProfile. detailed: true adds composite skins and skin lines, per-layer states of layer combinations, dash/symbol items of line types, vector hatch lines, all pens of a pen table, profile size, dimension formats. Without type: returns the number of attributes of every type. Layer/LayerCombination results include the active layer combination.

Creates layers (visible and unlocked unless stated; intersection group 1). Then place elements on them with the 'layer' field of any create_*/modify_elements tool. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates layer combinations (saved sets of layer visibility/lock/wireframe/intersection states). By default a new combination captures the CURRENT state of every layer, then 'layers' overrides are applied in order, e.g. {name: 'Plan - structure', base: 'allHidden', layers: [{match: 'Structural*', visible: true}]}. Activate one with apply_layer_combination. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates composite (multi-skin) structures for walls, slabs, roofs and shells. Skins are listed from the outside/reference side to the inside, each {thickness (m), buildingMaterial, core?, finish?}; the total thickness is the sum. Example: {name: 'Wall 380', skins: [{thickness: 0.02, buildingMaterial: '', finish: true}, {thickness: 0.25, buildingMaterial: '', core: true}, {thickness: 0.1, buildingMaterial: ''}, {thickness: 0.01, buildingMaterial: '', finish: true}]} (get building material names with get_attributes type BuildingMaterial). Use the composite with the 'composite' field of create_walls / create_slabs / create_roofs. basedOn copies an existing composite. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates building materials (the material of elements and composite skins: cut fill + pens, surface, intersection priority, physical properties). Unspecified settings are copied from 'basedOn' or, when omitted, from the first building material of the project — so give at least cutFill, surface and uiPriority for a meaningful material. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates surfaces (3D materials: color, reflection, transparency, 3D hatch, texture). Unspecified settings are copied from 'basedOn' or, when omitted, from the first surface of the project (without its texture). Example: {name: 'Red paint', color: '#B22222', transparency: 0}. Glass: {materialType: 'Glass', color: '#9FC5E8', transparency: 70}. Advanced Cineware (CineRender) channels are not accessible through the API. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates fill types: Solid (percentage/screen fill with percent: 25, or an explicit bitmapPattern, e.g. '55AA55AA55AA55AA' = 50%), Empty, Vector (hatch lines in mm on paper, e.g. {name: 'Diagonal 2mm', lines: [{angle: 45, spacing: 2}]}; with scaleWithPlan: true the values are meters in the model, e.g. a 0.3 m tile grid [{angle: 0, spacing: 0.3}, {angle: 90, spacing: 0.3}]), LinearGradient / RadialGradient, Image (texture). Symbol fills and any other fill can be copied with basedOn / duplicate_attributes. Use fills in building materials (cutFill), hatches, zone/slab cover fills. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates line types: Solid, Dashed ({name: 'Dash 3-1.5', dashes: [{dash: 3, gap: 1.5}]} — millimeters on paper unless scaleWithPlan: true, then meters in the model) or Symbol (items; easier: copy an existing symbol line with basedOn). Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates zone categories {name, code, color, stamp?}. Without 'stamp' the zone stamp (and its parameters) is copied from 'basedOn' or from the first zone category of the project. Assign it to zones with the zone tools' category field. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Creates complex profiles (custom cross-sections for walls, beams, columns, handrails) from polygons: each shape is {polygon (m, x horizontal / y vertical, straight edges), buildingMaterial, core?}. Example: a 0.3 x 0.5 m rectangular beam: {name: 'Beam 300x500', usage: {beams: true, columns: true}, shapes: [{polygon: [{x:-0.15,y:0},{x:0.15,y:0},{x:0.15,y:0.5},{x:-0.15,y:0.5}], buildingMaterial: ''}]}. Stretch zones/parameters are not supported (edit in Archicad's Profile Manager). basedOn copies an existing profile. Use it with the 'profile' field of walls/columns/beams. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Copies existing attributes of any type except Pen/Font (e.g. a pen set, a symbol fill, an MEP system, a model view option, a dimension standard, an operation profile, a composite) under a new name, optionally changing fields on the copy: each item is {source, name, folder?, ...fields of that type as in the create_* tools / modify_attributes}. Runs in one undo step. Returns {results: [{index, name, guid, created: true} | {..., existed: true} | {error}]} in input order; one failing item does not stop the others. Names are localized (Russian Archicad): look existing attributes up with get_attributes first.

Changes existing attributes of any type in one undo step. Each item is {type, attribute (name/index/{guid}), name? (rename), folder? (move), ...fields to change} with the same field names as get_attributes returns and the create_* tools accept; only the given fields change. Examples: {type: 'Layer', attribute: 'Мебель', locked: true}; {type: 'Surface', attribute: 'Red paint', color: '#AA0000'}; {type: 'Composite', attribute: 'Wall 380', skins: [...]}; {type: 'Pen', attribute: 12, color: '#FF0000', width: 0.5}; {type: 'LayerCombination', attribute: 'Plan', base: 'current'} (re-captures the current layer states). Fonts cannot be modified. Returns {results: [{index, name, guid} | {error}]}.

Deletes attributes of one type (one undo step). Archicad reassigns elements that used a deleted attribute (check them afterwards). WARNING: deleting a LAYER deletes every element on it — the tool refuses layers that still hold elements unless force: true (move elements with modify_elements first). Pens, fonts, the Archicad layer and some built-in attributes (the last one of a type, Solid/Empty fills, line type 1) cannot be deleted. Returns {results: [{index, name, deleted: true} | {error}]}.

Changes pen colors, weights and descriptions (pens cannot be created: there are always 255). Without penTable the pens in effect in the model are changed; with penTable a stored pen set is edited (it does not become active). Read the current pens with get_attributes {type: 'Pen'} or {type: 'PenTable', detailed: true}. Returns {results: [{index, color, width} | {error}], activePenTable | penTable}.

Makes a saved layer combination active in the current model window (sets the visibility/lock/wireframe of all layers). List combinations with get_attributes {type: 'LayerCombination'}. Returns {ok, layerCombination, activeLayerCombination}.

Shows/hides, locks/unlocks, switches wireframe or the intersection group of layers directly (the active layer settings; saved combinations are not changed — use modify_attributes type LayerCombination for those). Items run in order in one undo step, so 'isolate' works as [{match: '*', hidden: true}, {layer: 'Стены', visible: true}]. The Archicad layer cannot be hidden/locked (skipped for patterns). Returns per item {changed: [{index, name}], changedCount, alreadyInStateCount, skipped?} | {error}.

Finds elements in the open project with combinable filters (type, story, layer, renovation status, visibility/editability, selection, Element ID pattern, library part name, group, hotlink, lock state, spatial region) and returns a paginated list [{guid, type, storyIndex, layer: {index, name}, elementId, boundingBox?, libraryPart?}] plus total/hasMore. All filters are optional and AND-combined; with no filter every main element is listed. Use the GUIDs with get_element_details, get_element_quantities, modify_elements, set_selection etc. For counts only use get_element_counts. Coordinates in meters.

Counts elements per type — optionally also per story, per layer and per renovation status — with the same filters as find_elements. Output: {total, byType: {Wall: 12, ...}, byStory?: [{storyIndex, storyName, total, byType}], byLayer?: [{layer, total, byType}] (largest first), byRenovationStatus?}. Good first call to get an overview of a project.

Calculated quantities of elements, as Archicad lists them: every field of the element type's quantity record with descriptive names. Units: lengths m, areas m², volumes m³, angles degrees, counts integers. Examples — Wall: volume, grossVolume, surfaceReferenceSide, surfaceOppositeSide, length, area (plan), minHeight/maxHeight, windowsSurface, doorsSurface; Slab: volume, topSurface, bottomSurface, edgeSurface, perimeter, holesSurface; Zone: area, netArea, calculatedArea, volume, perimeter, wallsSurface; Column/Beam: core/veneer volumes & surfaces; Window/Door: surface, width/height per side, sill/head heights; Roof/Shell/Mesh/Morph/Object/CurtainWall/Stair/Railing and their parts are supported too. 'Conditional' values follow the project's calculation rules. Also returns composite skins per building material and per-type totals (sums of additive fields) + building material volume totals. Get GUIDs from find_elements first.

Elements attached to or hosted by each given element: windows/doors of a wall, skylights of a roof/shell, openings cut into walls/slabs/beams, labels attached to the element; plus the owner/host (wall of a door, roof of a skylight, element of a label, curtain wall of a panel...). Optionally solid element operations (operators cutting this element / targets it cuts) and roof/shell trims. Output: [{guid, type, connectedCount, connected: {Window: [guid...], Door: [...], ...}, owner?, solidOperations?, trims?}]. For zone boundaries and wall joins use get_element_relations; for curtain wall/stair/railing parts use get_subelements.

Topological relations computed by Archicad. Zone: relatedElementsByType (walls, columns, slabs, doors, windows, curtain walls ... bounding or inside the zone), wallParts/beamParts/curtainWallSegmentParts (boundary pieces: zoneEdgeIndex, tBegin, tEnd), niches (height, polygon). Wall: connectionPolygon (real plan outline after joins) and the walls connected at its begin/end, to its reference line, with their ends, or crossing it. Beam: the same for beams, plus per segment. Window/Door/Skylight/CurtainWallPanel: fromZone/toZone (the zones on both sides). Roof/Shell: zones below. Other types return an error item.

Parts of hierarchical elements, grouped by type: CurtainWall → CurtainWallSegment/Frame/Panel/Junction/Accessory (frames and panels with className, begin/end or centroid, hidden/degenerate flags); Stair → Riser/Tread/StairStructure (sequenceNumber, landing flag); Railing → RailingSegment/Node/Post/InnerPost/Toprail/Handrail/Rail/Panel/BalusterSet/Baluster/Pattern and rail ends/connections; Beam → BeamSegment; Column → ColumnSegment. Passing a sub-element GUID returns its owner. The part GUIDs work with get_element_details, get_element_quantities and get_element_3d_geometry.

Returns what is currently selected in Archicad: {selectionType: None|Elements|MarqueePolygon|MarqueeBox|MarqueeRotatedBox, total, editableCount, elements: [{guid, type, storyIndex, layer, elementId, partial?}], marquee?: {box, polygon, boxRotationAngle, multiStory}}. Use it when the user refers to 'the selected elements' or 'this'.

Changes the Archicad selection (shows the user which elements you mean, or prepares a selection-based command). mode 'set' replaces the selection (no elements = clear), 'add' adds, 'remove' deselects the given elements, 'clear' deselects everything. Elements on hidden/locked layers or on another story than the active floor plan may fail — see 'failed'. Output: {mode, requested, applied, failed: [{guid, error}], selectionCount}. Selection changes are not undo steps.

The 2D drawing primitives Archicad draws for elements in the active window (floor plan, section, layout...): lines, arcs/circles/ellipses, polylines, polygons (with holes; fills), texts and pictures, with pen numbers and a role for special parts (fill, openingDimension, arrow, drawingBorder). Helps to understand what a plan looks like (e.g. a door's swing, an object's symbol). Output per element: {guid, type, total, counts, extent {xMin,yMin,xMax,yMax}, primitives: [{kind, pen, ...}], truncated?, hotspots?}. Coordinates are [x, y] arrays in meters; angles in degrees; arcs in polygons use {index, angle} like polygon inputs. Hatch pattern lines are only counted unless includeFillPatterns=true. Use summaryOnly for large elements.

3D model data of elements as generated by Archicad. mode 'summary' (default): bodyCount, vertexCount, edgeCount, polygonCount, world boundingBox {xMin..zMax} (m, z absolute) and the materials used (surface attribute or GDL material name, polygon count). mode 'mesh': additionally bodies: [{source (element/part GUID), bodyIndex, closed, material, vertices: [[x,y,z], ...], polygons: [{v: [0-based vertex indices of the outer contour], holes?, material?, normal?}]}] within a vertex/polygon budget. Curtain walls, stairs, railings, beams and columns include their parts. 2D elements have no 3D model (error item).

Moves elements of ANY type (walls, slabs, objects, zones, lines, dimensions, ...) by a displacement vector, like Edit > Move > Drag. Pass elements + vector to move them all by the same offset, or moves to move different sets by different vectors (all in one undo step). A z component moves model elements vertically (use elevate_elements for pure vertical moves). Windows/doors move along their host wall; connected dimensions and labels follow automatically. Returns {results: [{guid, newGuid?, warning?} | {guid, error}], warnings?} in input order (a 'warning' on an item means Archicad may have ignored it); with copy=true the copy-style result {results: [{guid, copies: [new GUIDs]}], createdCount, additionalCreated?}. Locked elements, elements on locked/hidden layers, hotlinked elements and elements outside your Teamwork workspace are reported with an actionable error instead of being edited. With moves the result is {operations: []}.

Duplicates elements of ANY type displaced by vector (Edit > Move > Drag a Copy); the originals stay. count > 1 makes a linear array (copy k at k × vector, e.g. 10 columns every 6 m: vector {x: 6, y: 0}, count 10). Copies keep all settings, story, layer and properties of their original; copying a wall also copies its windows/doors. To duplicate onto other stories use copy_elements_to_stories. Returns {results: [{guid (original), copies: [new GUIDs]} | {guid, error}], createdCount, createdGroups? (GUIDs of the new groups holding the copies when whole groups were copied), additionalCreated?: [{guid, type, storyIndex}] (dependent elements created with the copies: openings of copied walls, copied group members, associative dimensions/labels), subElementsCreated? (curtain wall / stair / railing parts), warnings?}.

Rotates elements of ANY type in plan around a centre point (Edit > Move > Rotate). Angle in DEGREES, positive = counter-clockwise. Without center the centre of the elements' combined bounding box is used (reported in warnings). With copy=true the originals stay and count copies are made at k × angle (polar array, e.g. 6 chairs around a table: angle 60, count 5, copy true). Returns move-style results, or copy-style results ({results: [{guid, copies}], createdCount, additionalCreated?}) when copy=true.

Mirrors elements of ANY type across a line in plan (Edit > Move > Mirror). Give the mirror line either by two points (axisStart, axisEnd) or as axis: 'Vertical' | 'Horizontal' through through (default: centre of the elements' bounding box). copy=true keeps the originals and creates mirrored copies (e.g. the other half of a symmetric plan). Mirroring flips wall/door opening sides and object handedness like Archicad does. Returns {results: [{guid, newGuid?, warning?} | {guid, error}], warnings?} in input order (a 'warning' on an item means Archicad may have ignored it); with copy=true the copy-style result {results: [{guid, copies: [new GUIDs]}], createdCount, additionalCreated?}. Locked elements, elements on locked/hidden layers, hotlinked elements and elements outside your Teamwork workspace are reported with an actionable error instead of being edited.

Moves model elements vertically by deltaZ meters (Edit > Move > Elevate); positive = up. Heights/offsets relative to the home story change accordingly (e.g. a wall's bottom offset, an object's elevation); the home story does not change (use modify_elements storyIndex or copy_elements_to_stories for that). 2D elements (lines, fills, texts, labels, dimensions, drawings...) have no elevation and are reported as per-item errors. copy=true with count stacks copies at k × deltaZ. Returns {results: [{guid, newGuid?, warning?} | {guid, error}], warnings?} in input order (a 'warning' on an item means Archicad may have ignored it); with copy=true the copy-style result {results: [{guid, copies: [new GUIDs]}], createdCount, additionalCreated?}. Locked elements, elements on locked/hidden layers, hotlinked elements and elements outside your Teamwork workspace are reported with an actionable error instead of being edited.

Scales elements in plan by ratio around a centre point (Edit > Reshape > Resize): 2 = double size, 0.5 = half. Default centre: the elements' bounding-box centre. Model element heights are not scaled; text/labels scale according to Archicad rules. Returns {results: [{guid, newGuid?, warning?} | {guid, error}], warnings?} in input order (a 'warning' on an item means Archicad may have ignored it); with copy=true the copy-style result {results: [{guid, copies: [new GUIDs]}], createdCount, additionalCreated?}. Locked elements, elements on locked/hidden layers, hotlinked elements and elements outside your Teamwork workspace are reported with an actionable error instead of being edited.

Deletes elements of ANY type (one undo step: undo restores them). Dependent elements are removed by Archicad too and are reported: windows/doors of deleted walls, associative dimensions and labels, etc. -> alsoDeleted: [{guid, type}], subElementsDeleted (curtain wall / stair / railing parts). Only delete elements you created or were asked to delete. Group GUIDs delete the whole group. Returns {results: [{guid, deleted: true} | {guid, error}], deletedCount, alsoDeleted?, subElementsDeleted?, warnings?}.

Duplicates elements onto other stories at the same plan position, keeping their elevation RELATIVE to the home story (like copy + Paste to stories: a wall with bottom offset 0 on story 0 becomes a wall with bottom offset 0 on story 2). Top-linked walls/columns stay linked relative to their new home story. Copy walls/roofs/slabs rather than their windows/doors: hosted openings travel with their host. List stories with get_stories. Returns {results: [{guid (original), copies: [{storyIndex, guid} | {storyIndex, error}]}], additionalCreated?, subElementsCreated?, warnings?}.

Groups elements (Edit > Grouping > Group) so they move/select together. Elements that already belong to a group bring their whole top-level group, which becomes a nested sub-group (same as Archicad). All elements must be on the same story. Pass elements for one group, or groups: [{elements, parentGroup?}] for several in one undo step. Returns {groupGuid, members, elementCount} (with groups: {results: [...]}). The group GUID can be passed to move_elements, delete_elements, ungroup_elements, ... to address the whole group.

Dissolves groups (Edit > Grouping > Ungroup). Pass group GUIDs, or any member element (its top-level group is dissolved). One level per call like Archicad: nested sub-groups survive unless completely=true. Returns {results: [{guid, dissolvedGroups: [guid], elementCount, remainingGroup?} | {guid, error}]}.

Reads or switches Archicad's 'Suspend Groups' mode (Edit > Grouping). When ON, members of groups can be selected and edited individually. The edit tools of this connector already handle groups via includeGroupMembers, so this is only needed for manual workflows. Omit suspend to just read the state. Returns {suspendGroups, changed}.

Locks elements (Edit > Locking > Lock): locked elements cannot be edited, moved or deleted until unlocked (unlock_elements). Returns {results: [{guid, locked: true} | {guid, error}], warnings?}.

Unlocks locked elements (Edit > Locking > Unlock). Call this when another tool reports 'is locked'. Elements on a LOCKED LAYER need the layer unlocked instead (layer attribute tools). Returns {results: [{guid, locked: false} | {guid, error}]}.

Changes the 2D stacking (display) order of elements on the plan (Edit > Display Order): which element covers which (e.g. a fill behind lines). Give action ('BringToFront' | 'BringForward' | 'SendBackward' | 'SendToBack' | 'Reset' = default order of the type; steps repeats BringForward/SendBackward) OR a target level 1 (bottom) .. 14 (top). Type defaults: drawings 5, fills/zones 6, walls/slabs/roofs/columns/doors/windows 7, objects/lamps 8, lines/arcs/polylines/beams 9, texts/labels/dimensions 10. Windows/doors cannot go below their host. Returns {results: [{guid, drawIndexBefore, drawIndex, warning?}]}.

Trims construction elements (walls, columns, beams, slabs, roofs, shells, curtain walls, windows/doors/skylights) to a Roof or Shell (Design > Connect > Trim Elements to Roof/Shell), e.g. cut gable walls to the roof slope. With trimWith (a roof/shell GUID) every element in elements is trimmed by it using trimType; without it the roofs/shells contained in elements trim the other elements (default: keep the part below/inside). Returns {results: [{guid, trimmedBy: [{guid, trimType}]} | {guid, error}]}; undo with remove_trim.

Removes trim-to-roof/shell connections, restoring the untrimmed elements. Give explicit pairs [{element, trimmingElement}] and/or elements (all trim connections of these elements are removed, whether they are trimmed or trimming). Inspect trims with get_element_edit_relations. Returns {results: [{element, trimmingElement, removed: true} | {element, trimmingElement, error}], removedCount}.

Merges construction elements (Design > Connect > Merge) so their 3D bodies and sections are displayed as one without contour lines between them (e.g. slabs of the same material). Needs at least two elements. Undo with unmerge_elements. Returns {merged, results: [{guid, mergedWith: [guid]}]} (merged=false with per-element errors when some element is not editable).

Removes merge connections created by merge_elements. Give pairs [{element, otherElement}] and/or elements (all merges of these). Returns {results: [{element, otherElement, removed: true} | {..., error}], removedCount}.

Solid Element Operations (Design > Solid Element Operations): cut or add 3D volumes between construction elements - e.g. subtract a morph/slab/object from walls to make a niche, cut walls with SubtractUpwards/SubtractDownwards against a roof or slab. By default (permanent=false) a LIVE link is created: it updates when elements move, operators are usually put on a hidden layer afterwards, and it can be removed with remove_solid_operation. permanent=true performs a destructive Boolean on MORPHS only: target and operators are replaced by the result morph(s). Give target/operators/operation for one operation or operations for several (one undo step). Returns {results: [{target, links: [{operator, operation} | {operator, error}]}]} or, when permanent, [{target, resultMorphs: [guid]}].

Removes live solid element operation links (created by solid_operation or in Archicad). Give links [{target, operator}] and/or elements (every link where the element is target or operator). Inspect links with get_element_edit_relations. Returns {results: [{target, operator, removed: true} | {target, operator, error}], removedCount}.

Read-only. For each element returns what affects editing it: type, storyIndex, locked, editable, drawIndex, group membership (groupGuid, rootGroupGuid, groupElements), hotlinkGuid, trimmedBy / trims (trim-to-roof connections with trimType), mergedWith, solidOperators (elements cutting/adding to it) and solidTargets (elements it cuts). Use it to verify group/trim/merge/solid operations or to find out why an edit was refused.

Creates columns (one undo step): rectangular, circular, complex-profile, tapered, slanted and multi-segment columns, with veneer, wall wrapping and surface overrides. Coordinates in meters, angles in degrees, on the given story (default: current story). Unspecified settings come from the Column tool defaults — give 'height' (unlinked) or 'topLinkedStory' (+ topOffset) so the height is what you expect. Typical: {origin: {x: 0, y: 0}, height: 3, width: 0.4, depth: 0.4, buildingMaterial: ''}. Returns [{guid, type} | {error}] in input order; read the result back with get_element_details (segments, cuts, elevations).

Creates beams (one undo step): straight, horizontally or vertically curved, slanted, tapered, complex-profile and multi-segment beams, with holes and surface overrides. Coordinates in meters, angles in degrees, on the given story (default: current story). 'level' is the height of the reference axis (by default the beam top) above the home story — e.g. story height 3 m and a beam under the slab: level 2.8. Unspecified settings come from the Beam tool defaults. Chain beams end-to-start so Archicad connects them. Typical: {begin: {x: 0, y: 0}, end: {x: 6, y: 0}, level: 3, width: 0.3, height: 0.5}. Returns [{guid, type} | {error}] in input order.

Changes existing columns (one undo step). Each item is {guid, ...fields to change} using exactly the fields of create_columns (origin, height, topLinkedStory, width/depth/diameter, buildingMaterial/profile, surfaces, veneer, slant, anchor, lines, ...); only the given fields change and they are validated like create_columns. Top-level section/surface/veneer fields apply to ALL segments; use 'segments' (full list, {} = unchanged segment; a different length changes the segment count) for single segments and 'cuts' for segment cuts. Read the current values first with get_element_details. Non-column GUIDs are rejected per item. Returns [{guid} | {error}] in input order.

Changes existing beams (one undo step). Each item is {guid, ...fields to change} using exactly the fields of create_beams (begin, end, level, width/height/diameter, arcAngle, slantAngle, buildingMaterial/profile, surfaces, anchor, lines, ...); only the given fields change and they are validated like create_beams. Top-level section/surface fields apply to ALL segments; use 'segments' (full list, {} = unchanged segment) for single segments or the segment count. Holes: 'holes' replaces all, 'addHoles' appends, 'removeHoles' deletes by id. Read the current values first with get_element_details. Non-beam GUIDs are rejected per item. Returns [{guid} | {error}] in input order.

Creates slabs (floors, ceilings, flat roofs, terraces) from a plan polygon with optional curved edges (arcs) and holes. 'level' is the elevation of the slab's reference plane above the home story — pass referencePlane: 'Top' to make level = top of the slab (the tool default may differ; get_element_details shows referencePlane and offsetFromTop), 'thickness' in m, structure by 'buildingMaterial' or 'composite'. Edge trims (Vertical or CustomAngle with edgeAngle) for all edges or per edge via 'edges', surface overrides, floor plan pens/fills. Example: {polygon: [{x:0,y:0},{x:8,y:0},{x:8,y:6},{x:0,y:6}], thickness: 0.25, level: 0}. A self-intersecting polygon is regularized automatically when it stays one piece. Units: meters and degrees; coordinates are project coordinates on the home story (default: current story; 'storyIndex' to choose). Unspecified settings come from the tool defaults. Attribute names (building materials, composites, surfaces, fills, line types, layers) are LOCALIZED — look them up with get_attributes. Returns [{guid, type} | {error}] in input order (one undo step; a failing item does not stop the others). Read results back with get_element_details (same field names).

Creates roofs. SinglePlane: one sloped plane — 'polygon' (roof outline in plan incl. overhang), 'pivotLine' {begin, end} (the horizontal line at elevation 'level' the plane pivots around, usually the eaves), 'slopeAngle' (degrees); the plane rises towards the polygon unless risesToLeft is given. Two single-plane roofs with opposite pivot lines make a gable roof. MultiPlane: a hip roof over any closed 'pivotPolygon' (usually the outer wall outline at the wall top: level = wall height) with 'slopeAngle' or 'levels' (pitch breaks, e.g. mansard), 'eavesOverhang', and per-plane 'pivotEdges' overrides (gable: true turns that side into a vertical gable end, angle changes its pitch). 'thickness', 'buildingMaterial'/'composite', surfaces and floor plan attributes as for slabs. Example hip roof: {pivotPolygon: [{x:0,y:0},{x:10,y:0},{x:10,y:8},{x:0,y:8}], level: 3, slopeAngle: 30, eavesOverhang: 0.5, thickness: 0.3}. Units: meters and degrees; coordinates are project coordinates on the home story (default: current story; 'storyIndex' to choose). Unspecified settings come from the tool defaults. Attribute names (building materials, composites, surfaces, fills, line types, layers) are LOCALIZED — look them up with get_attributes. Returns [{guid, type} | {error}] in input order (one undo step; a failing item does not stop the others). Read results back with get_element_details (same field names).

Creates shells (free-form roofs/vaults/domes/canopies). Extruded: an open 'profile' polyline drawn in the profile plane (x across, y up) swept from 'begin' along the 3D 'extrusion' vector — e.g. a barrel vault: {profile: {points: [{x:-3,y:0},{x:3,y:0}], arcs: [{index:0, angle:-180}]}, begin: {x:0,y:0,z:3}, extrusion: {x:0,y:12,z:0}}. Revolved: 'profile' {x = distance from the axis, y = height} revolved by 'revolutionAngle' (default 360) around the vertical axis through 'axisOrigin' — e.g. a dome. Ruled: surface between 'profile' on 'plane1' and 'profile2' on 'plane2'. 'closedProfile': true for closed sections (tubes). 'thickness', 'flipped' (side of the thickness), structure, surfaces, edge trim and floor plan attributes as for roofs. Check the result in 3D and read the stored geometry with get_element_details (basePlane, profile, extrusion ...) — copy those values from an existing shell for exact placement. Units: meters and degrees; coordinates are project coordinates on the home story (default: current story; 'storyIndex' to choose). Unspecified settings come from the tool defaults. Attribute names (building materials, composites, surfaces, fills, line types, layers) are LOCALIZED — look them up with get_attributes. Returns [{guid, type} | {error}] in input order (one undo step; a failing item does not stop the others). Read results back with get_element_details (same field names).

Creates meshes (terrain / site surfaces). 'polygon' points carry heights: {x, y, z} with z relative to the mesh base 'level'; add inner 'levelLines' (ridges / contour lines, each point with z) to shape the surface inside the outline; holes allowed. 'skirt': SolidBody | SkirtWithoutBottom | SurfaceOnly, 'skirtLevel' = depth of the body below the base plane. 'ridges' controls smooth/sharp display. Example: {polygon: [{x:0,y:0,z:0},{x:30,y:0,z:1},{x:30,y:20,z:2.5},{x:0,y:20,z:0.5}], level: -0.1, skirt: 'SolidBody', skirtLevel: 1}. Units: meters and degrees; coordinates are project coordinates on the home story (default: current story; 'storyIndex' to choose). Unspecified settings come from the tool defaults. Attribute names (building materials, composites, surfaces, fills, line types, layers) are LOCALIZED — look them up with get_attributes. Returns [{guid, type} | {error}] in input order (one undo step; a failing item does not stop the others). Read results back with get_element_details (same field names).

Changes existing slabs: polygon (outline incl. holes — replaces the shape and resets per-edge data), thickness, level, referencePlane, structure, surfaces, edge trims (all edges or per edge via 'edges'), floor plan attributes, layer, story, renovation status, element ID. Fields as in create_slabs. Only the given fields change; the others keep their values. Each item must be an element of this type (checked first; other items still run). Returns [{guid} | {error}] in input order, one undo step.

Changes existing roofs (the class SinglePlane/MultiPlane cannot change). SinglePlane: polygon, pivotLine, slopeAngle, risesToLeft, edges. MultiPlane: pivotPolygon, slopeAngle, levels, eavesOverhang, pivotEdges (per-plane pitch / gable end / overhang; edge indices of the stored pivot polygon as returned by get_element_details). Both: level, thickness, structure, surfaces, edge trim, floor plan attributes. Fields as in create_roofs. Only the given fields change; the others keep their values. Each item must be an element of this type (checked first; other items still run). Returns [{guid} | {error}] in input order, one undo step.

Changes existing shells (the class Extruded/Revolved/Ruled cannot change): profile / profile2 / closedProfile, placement (begin, extrusion, axisOrigin, profileRotation, basePlane, plane1/plane2), angles, thickness, flipped, structure, surfaces, floor plan attributes. Fields as in create_shells. Only the given fields change; the others keep their values. Each item must be an element of this type (checked first; other items still run). Returns [{guid} | {error}] in input order, one undo step.

Changes existing meshes: polygon with point heights (replaces the outline incl. holes), levelLines ([] removes them), level, skirt, skirtLevel, ridges, building material, surfaces, floor plan attributes. Fields as in create_meshes. Only the given fields change; the others keep their values. Each item must be an element of this type (checked first; other items still run). Returns [{guid} | {error}] in input order, one undo step.

Places windows into walls (one undo step). Each window needs its host 'wall' GUID and either 'position' (m from the wall's begin point to the window centre along the reference line) or 'point' ({x,y} projected onto the wall). sillHeight = bottom of the window above the wall bottom. Unspecified settings (library part, size, sill, reveal, surfaces) come from the Window tool defaults. Library part names are LOCALIZED: find them with search_library_parts (type Window). Polygonal walls cannot host windows. Returns [{guid, type} | {error}] in input order; inspect results with get_element_details (position, location, sill/header height, library part, key GDL params).

Places doors into walls (one undo step). Each door needs its host 'wall' GUID and either 'position' (m from the wall's begin point to the door centre along the reference line) or 'point' ({x,y} projected onto the wall). Use flipped (opening side) and mirrored (hinge side) to orient it; sillHeight is usually 0. Unspecified settings come from the Door tool defaults. Library part names are LOCALIZED: find them with search_library_parts (type Door). Returns [{guid, type} | {error}] in input order.

Places skylights into roofs or shells (one undo step). Each skylight needs the host 'owner' (Roof or Shell GUID) and 'point' ({x,y}: plan position of its anchor on the roof). Size, library part and parameters default to the Skylight tool settings; library part names are LOCALIZED (search_library_parts, type Skylight). Returns [{guid, type} | {error}] in input order.

Creates Opening-tool openings: rectangular or circular extrusion bodies that cut holes through their host (wall, slab, roof, shell, beam, column, mesh) — e.g. shafts through slabs, service holes in walls or beams. Each needs 'owner', 'width' (+ 'height' unless circular) and 'point' ({x,y,z?} plan anchor) or, for walls, 'position' along the wall. Wall openings extrude horizontally through the wall: set their height with bottomElevation (bottom edge above the home story). Slab/roof openings extrude vertically by default (limit 'Infinite' cuts through the whole host). Custom polygonal shapes are not supported by the Archicad 26 API. Returns [{guid, type} | {error}] in input order.

Changes existing windows, doors, skylights and Opening-tool openings in one undo step. Each item is {guid, ...fields to change} with the same field names as create_windows / create_doors / create_skylights / create_openings (e.g. move a window: position; resize: width/height; swap the library part: libraryPart; GDL: gdlParams; flip: flipped / mirrored). Openings keep their anchorAltitude when anchor/height change — pass bottomElevation to keep the bottom edge instead. The host (wall / roof / owner) cannot be changed — delete and recreate instead. Returns [{guid} | {error}].

Lists the windows, doors, skylights and Opening-tool openings placed in the given host elements (walls, roofs, shells, slabs, beams, ...). details=false (default) returns GUIDs only; details=true returns the full element details of every opening (position, size, library part...).

Places GDL objects (furniture, equipment, fixtures, custom parts from create_library_part, ...) in one undo step. Each item needs a libraryPart (Object type — names are LOCALIZED, so find them first with search_library_parts {query, type: 'Object'}) and a position (meters). Optional: elevation above the home story, angle (degrees CCW), mirrored, sizes sizeA (X) / sizeB (Y) / height (ZZYZX), any GDL params by name (see get_library_part_details), pen/line/surface overrides, story visibility, layer, storyIndex. Returns [{guid, type} | {error}] in input order. Lamps: create_lamps. Doors/windows: the opening tools. Later changes: modify_elements (same fields), set_gdl_parameters, change_library_part.

Places lamps (light-emitting GDL library parts of type 'Lamp': ceiling lights, spots, floor lamps, ...) in one undo step. Same fields as create_objects plus lightOn, lightColor {red, green, blue} (0..1) and lightIntensity. Find lamp names with search_library_parts {type: 'Lamp'} (names are localized). Typical ceiling light: elevation = ceiling height minus the lamp height. Returns [{guid, type} | {error}].

Finds library parts (objects, doors, windows, lamps, zone stamps, labels, skylights, macros ...) in the loaded libraries. Names are LOCALIZED — on a Russian Archicad search Russian words (e.g. 'стол' table, 'стул' chair, 'дверь' door, 'окно' window, 'светильник' lamp, 'кровать' bed, 'шкаф' cabinet, 'диван' sofa, 'унитаз' WC, 'раковина' sink, 'дерево' tree). The query is a case-insensitive substring; with several words all must match the name or file name. Exact and prefix matches come first. Filter by type, by subtype (category: a keyword like 'Furnishing', 'Plant', 'Light' or a template from get_library_part_subtypes), or embeddedOnly (parts created with create_library_part). Returns {libraryParts: [{index, name, guid, type, fileName, subtype}], total, hasMore}. Use the name or {guid} as libraryPart in create_objects / create_lamps / change_library_part.

Lists the library part subtype tree (categories such as Model Element > Building Element > Furnishing > Chair — names localized) with each subtype's path, parent, type and number of placeable parts directly under it. Use it to browse the library by category, then search_library_parts {subtypeOf: {guid}} to list the parts of a category, or pass a subtype to create_library_part.

Everything about library parts before placing them: identity (name, guid, index, type, file), file location and containing library, subtype/ancestry, creator tool, sections, comment/keywords, default sizes (sizeA, sizeB, height) and the DEFAULT GDL parameters [{name, type, description, value, valueDescription?, hidden?, arrayDims?, valueList?}] — the parameter names are what create_objects params and set_gdl_parameters expect. includeValueLists adds the allowed values/ranges from the parameter script (slower: use with parameterNames).

Returns the GDL source of a library part: masterScript, script2D, script3D, parameterScript, interfaceScript, propertiesScript (default), and on request forwardMigrationScript, backwardMigrationScript, comment, keywords. Great for learning how a standard part works or as a starting point for create_library_part. Encrypted parts return errors. Long scripts are cut at maxLength characters.

Creates a custom GDL library part (object, lamp, door, window, skylight, label, zone stamp) in the project's EMBEDDED library from GDL scripts and a parameter list, then returns its {libraryPart: {name, guid, index}} so create_objects / create_lamps can place it. Use it for anything the standard library lacks (custom furniture, built-ins, fixtures, signage, parametric equipment). overwrite: true replaces an existing embedded part of the same name (placed instances keep their link and update). Defaults: type 'Object' with subtype ModelElement; a ZZYZX (height) Length parameter is added for objects/lamps; when script2D is omitted for objects/lamps it is 'PROJECT2 3, 270, 2' (plan symbol = top view of the 3D model). Verify with get_library_part_scripts, then place it and look at it (3D view / get_element_details); GDL errors show up as missing geometry.

GDL QUICK REFERENCE (units: meters, angles in DEGREES):

• Local system: origin = insertion point, X along A (width), Y along B (depth), Z up, ZZYZX = height. Every parameter is a variable in all scripts; A, B (and ZZYZX for objects) always exist.

• masterScript runs before the 2D, 3D and parameter scripts: compute shared variables there. One statement per line; '!' starts a comment; strings in "..." or '...'.

• 3D transformations (a stack): ADDX dx / ADDY dy / ADDZ dz / ADD dx, dy, dz; ROTX a / ROTY a / ROTZ a; MULX f / MUL fx, fy, fz; DEL n (undo the last n), DEL TOP (undo all).

• 3D bodies at the current origin: BLOCK a, b, c (box along +X +Y +Z); PRISM_ n, h, x1, y1, s1, ..., xn, yn, sn (vertical extrusion of a polygon; s = 15 for visible edges); CPRISM_ topMat, botMat, sideMat, n, h, x1, y1, s1, ...; CYLIND h, r (along Z); SPHERE r; ELLIPS h, r; CONE h, r1, r2, 90, 90; REVOLVE n, alpha, mask, x1, y1, s1, ... (profile in the XY plane revolved around X); EXTRUDE n, dx, dy, dz, mask, x1, y1, s1, ...; TUBE; RULED; SLAB_.

• Attributes: MATERIAL m (surface name, index or a Surface parameter) before the bodies; PEN p; RESOL n (segments of curved surfaces); HOTSPOT x, y, z (3D editing point).

• 2D script (plan symbol): PROJECT2 3, 270, 2 (top view of the 3D model), or draw: LINE2 x1, y1, x2, y2; RECT2 x1, y1, x2, y2; POLY2_ n, frameFill, x1, y1, s1, ... (frameFill 1 = contour, 2 = fill, 4 = close; 7 = all); CIRCLE2 x, y, r; ARC2 x, y, r, a1, a2; FILL f before a filled POLY2_; HOTSPOT2 x, y; TEXT2 x, y, "text"; ADD2 dx, dy / ROT2 a / MUL2 fx, fy / DEL n.

• parameterScript: VALUES "len" 0.6, 0.8, 1.2 | VALUES "len" RANGE [0.3, 2.4] | VALUES "style" "Modern", "Classic"; LOCK "param"; HIDEPARAMETER "param"; PARAMETERS param = expression (store a computed value).

• Flow: IF c THEN ... ELSE ... ENDIF; FOR i = 1 TO n ... NEXT i; WHILE c DO ... ENDWHILE; GOSUB "sub" ... END ... "sub": ... RETURN. Operators + - * / ^ MOD = <> < > <= >= AND OR NOT; functions SIN COS TAN ATN (degrees), SQR (square root), ABS, MIN, MAX, INT, FRA, STR, PI.

• Example: table with parameters [{name:'topThk', type:'Length', value:0.04}, {name:'legW', type:'Length', value:0.05}, {name:'mat', type:'Surface', value:}], a: 1.6, b: 0.8, height: 0.75, script3D: MATERIAL mat ADDZ ZZYZX - topThk BLOCK A, B, topThk DEL 1 FOR i = 0 TO 1 FOR j = 0 TO 1 ADD i * (A - legW), j * (B - legW), 0 BLOCK legW, legW, ZZYZX - topThk DEL 1 NEXT j NEXT i (script2D omitted = PROJECT2 3, 270, 2)

Lists the libraries loaded in the project (Library Manager): name, path, type (Local, Embedded, BuiltIn, Server, Url ...), available, readOnly, plus the total number of library parts.

Adds local libraries to the project and loads them: absolute folder paths (or .lcf library container files) on this Mac; '~/' is expanded. Already loaded paths are reported as alreadyLoaded. NOT undoable. Returns per-path results and the new library list.

Removes libraries from the project by path or name (see get_libraries). The embedded and built-in libraries cannot be removed. Placed elements using parts of a removed library become 'missing objects'. NOT undoable.

Reloads all loaded libraries (picks up library part files changed on disk, fixes stale 'missing' parts).

Returns the GDL parameters of placed library-part based elements (objects, lamps, doors, windows, skylights, zones, symbol labels, ...): per element {guid, type, libraryPart, parameters: [{name, type, description, value, valueDescription?, hidden?, disabled?, arrayDims?, valueList?}]}. Lengths in m, angles in degrees. Filter with names (exact) or search (substring of name or localized description). includeValueLists adds allowed values/ranges and 'locked' state from the parameter script. Hidden parameters are skipped unless includeHidden or named explicitly.

Changes GDL parameters of placed objects, lamps, doors, windows, skylights, zones or labels in one undo step, running each part's parameter script like the settings dialog (dependent parameters update, invalid values are corrected or rejected). Give per-element params, and/or top-level params applied to every listed element (per-element values win). Changing A/B also resizes the element. Returns [{guid, parameters: resulting values} | {error}]. Parameter names: get_gdl_parameters.

Swaps the library part of placed objects, lamps, doors, windows, skylights, zones or symbol labels (e.g. replace a chair model, change a door type) in one undo step, keeping position/orientation. The new part must have the same type (Object for objects, Door for doors ...). keepParameters (default true) copies values of same-named, same-typed, visible, non-unique GDL parameters like Archicad does; keepSize (default true for doors/windows/skylights, false otherwise) keeps A/B. Extra params / sizeA / sizeB / height are applied afterwards. A top-level libraryPart applies to every element without its own. Returns [{guid, type, libraryPart, carriedOverParameters} | {error}].

Creates zones (rooms/spaces) in one undo step. Two modes per item: (1) MANUAL: 'polygon' = the outline in meters; (2) AUTOMATIC: 'referencePoint' = a point inside a room enclosed by walls/columns/room separators on that story — Archicad detects the outline (boundary 'InnerEdge' or 'ReferenceLine'); it fails with a clear error if the point is not enclosed. Create the walls first. Set name, number, category (localized ZoneCategory attribute, see get_attributes), height (m), bottomOffset, stamp position/angle, stamp library part + GDL parameters, fill/contour. Unspecified settings come from the Zone tool defaults. Returns [{guid, type} | {error}] in input order. Read areas/volumes back with get_zones.

Changes existing zones in one undo step: name, number, category, height/topLinkedStory/bottomOffset, area reduction, stamp (position, angle, library part, GDL parameters), fill/contour/surface, layer/story/elementId. Geometry: 'polygon' sets a new outline and makes the zone manual; 'referencePoint' makes it automatic around a new point; automatic:false freezes the current outline. Only the given fields change. Non-zone GUIDs are rejected per item. Returns {results: [{guid} | {guid?, error}]} in input order. Use get_zones / get_element_details to read current values.

Equivalent of Archicad's Design > Update Zones for AUTOMATIC zones: after walls/columns/room separators were moved, added or deleted, re-detects each zone's boundary from its reference point (a temporary zone is placed there and deleted again) and applies it. Manual zones are skipped (change them with modify_zones). Default: all automatic zones of the project (narrow with 'zones' or 'stories'). method 'copyBoundary' (default) keeps the zone GUID and writes the new polygon into it; 'recreate' replaces each zone by a new one with the same settings, stamp parameters, element ID, classifications and custom property values (NEW GUIDs, associative labels are lost) — use it only if copyBoundary reports an error or verified:false. dryRun:true only reports which zones are 'outdated'. Returns {results: [{guid, status: updated|upToDate|outdated|recreated|skipped, before/after areas, verified, newGuid?} | {guid, error}], summary}.

Lists zones (rooms) like a room schedule, sorted by story then number: guid, name, number, category, story, construction method (Manual / InnerEdge / ReferenceLine), area, netArea, calculatedArea (after reductions, as in the stamp) in m², perimeter (m), volume (m³), height, bottomElevation, stamp position, plus totals over ALL matching zones. Filter by guids, stories, category or a search text (name or number). Optional: includePolygon, includeQuantities (walls/doors/windows surfaces, corners, extracted areas...), includeRelations (boundary walls/beams, contained elements by type), includeReductions (area reductions with type/percent/area/polygon). For every setting of one zone use get_element_details.

Draws straight 2D lines (one undo step). Each line: begin/end points in meters plus optional pen, colorOverridePen, lineType, lineWeight (mm), category, zoneBoundary and arrows. Unspecified settings come from the Line tool defaults. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). For connected segments prefer create_polylines. Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details.

Draws 2D circular or elliptical arcs. Three ways to define each arc: (A) center + radius + beginAngle + endAngle (degrees, CCW from +X; add minorRadius/axisAngle for elliptical arcs); (B) begin + end + arcAngle (signed sweep, + = counter-clockwise); (C) begin + through + end (three points). Archicad stores arcs counter-clockwise, so a clockwise arc (negative arcAngle) is returned with begin/end swapped. Style fields as create_lines. Full circles: create_circles. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details.

Draws full 2D circles (center + radius in m) or ellipses (+ minorRadius and axisAngle in degrees). Style fields: pen, colorOverridePen, lineType, lineWeight, category, zoneBoundary. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details.

Draws 2D polylines: connected straight and curved segments (points + optional arcs {index, angle}), open or closed. Ideal for outlines, symbols and room-separator chains (zoneBoundary: true). Style fields as create_lines plus continuousPattern. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details. Modifying 'arcs' or 'closed' requires sending 'points' too (the geometry is replaced).

Draws smooth 2D Bezier splines through the given points (automatic natural spline), or with explicit Bezier handles (directions: one {angle, lengthPrev, lengthNext} per point). Open or closed. Style fields as create_lines. NOTE: Archicad cannot change the geometry of an existing spline — to reshape one, create a new spline and delete the old one (delete_elements); modify_elements can still change its pen, lineType, arrows etc. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others.

Creates 2D fill polygons (Archicad 'Fill' tool): a polygon in meters with optional arcs and holes, filled with a Fill pattern (fillType) or a building material's cut fill (buildingMaterial), with pens, RGB colour overrides, contour (on/off, pen, line type, weight), pattern orientation (rotated / distorted / radial, local origin), fill category and an optional area text. Attribute names are LOCALIZED — list them with get_attributes {type: 'Fill' | 'BuildingMaterial' | 'Line'}. get_element_details returns the polygon plus area and perimeter. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details.

Places text blocks (Archicad 'Text' tool): position (m) + text ('\n' = new line, any language incl. Cyrillic) or rich-text runs with per-run pen/font/size/bold/italic/underline/strikeout/superscript/subscript; plus anchor, justification, angle, widthFactor, charSpacing, wrapWidth (mm), frame, background, alwaysReadable. Text size is in MILLIMETERS on paper (it scales with the drawing scale unless fixedSize). Fonts by name ('Arial') — get_attributes {type: 'Font'}. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details. Restyling via modify_elements (e.g. {guid, size: 5, bold: true}) keeps the content.

Places labels with a leader line. ASSOCIATIVE labels (parent = element GUID) stick to the element and can show its data via the Label tool's autotext default content; INDEPENDENT labels need 'begin'. Leader: begin (arrow point) -> middle -> end (text). Text labels take text/runs and the same text style fields as create_texts; symbol labels (labelClass 'Symbol') use a Label library part (libraryPart, gdlParameters — find parts with search_library_parts {type: 'Label'}). For associative labels without 'end' Archicad uses its default label position. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details. The parent and the class of an existing label cannot be changed (delete and recreate).

Places hotspots (snap points) at 2D positions (m) with an optional elevation (height, m) and pen — useful as reference/snap points for later drawing. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Change them later with modify_elements using the same field names; read them back with get_element_details.

Places raster images (PNG, JPEG, GIF, TIFF, BMP) from ABSOLUTE file paths on this Mac, e.g. a logo on a layout or a site photo on a worksheet. Size in meters via width and/or height (aspect ratio kept when only one is given); without a size the picture is placed at its pixel size with its bottom-left corner at position. Optional anchor, angle, mirrored, transparent, name. Elements go into the database of the ACTIVE window: on a floor plan the given storyIndex (default: current story), otherwise the open section / elevation / detail / worksheet / layout (a 3D window cannot hold 2D elements). Returns [{guid, type} | {error}] in input order; one failing item does not stop the others. Position/size/angle can be changed later with modify_elements; the image itself cannot be replaced.

Creates linear dimension chains (one undo step). Each dimension = ordered 'points' + a dimension line (direction + linePoint/offset). Points: {x, y} static, or linked to elements (associative, the dimension follows edits): {element, at: 'begin'|'end'} for wall/beam/line reference-line ends, {element, x, y} for the element anchor (hotspot, corner, opening point) nearest to x,y — list anchors with get_dimension_anchors. Distances are measured along 'direction' (e.g. 'Horizontal' = X distances). Units: m; text/marker sizes in paper mm. Style defaults come from the Dimension tool settings. Dimensions linked to model elements are placed on the Floor Plan (story: storyIndex, default current); static ones go into the active window (plan, section, detail, worksheet, layout). Linked points that Archicad cannot resolve fall back to static (see 'warning'). For walls prefer dimension_walls (mode 'Thickness' for wall widths). Returns [{guid, type, pointCount, associativePoints, segments (measured lengths), total, linePoint} | {error}] in input order; one failing item does not stop the others.

Places level (elevation) dimension markers (one undo step). Each marker shows the story level at 'position', or the level of an 'element' (slab/mesh/roof/stair top), or a static 'level' value. Markers on an element are placed on the Floor Plan (story: storyIndex, default current); the others go into the active window (normally the Floor Plan). Units: m, degrees, marker/text sizes in paper mm. Unspecified settings come from the Level Dimension tool. Returns [{guid, type, position, level, static, element?, storyLevel} | {error}].

Dimensions the radius of arcs, circles, curved walls or curved beams (one undo step). The dimension is linked to the element and verified (the measured radius must match the element). 'at' picks where it touches the arc, 'lineEnd' where the radial line ends. Walls/beams must be on the Floor Plan; arcs/circles in the active window's drawing. Returns [{guid, type, radius, associative, element, arcPoint, lineEnd} | {error}].

Dimensions the angle between two non-parallel lines (one undo step): static 'line1'/'line2' {begin, end}, or two straight walls/beams/lines ('elements', linked to their end points when possible, verified, else static). The arc is centered on the lines' intersection; 'arcPoint' (a point on the arc) or 'radius' (m, default 1) places it; by default it sits between the far ends of both lines. Returns [{guid, type, angle (degrees), radius, center, arcPoint, associative} | {error}].

Automatically dimensions walls on the Floor Plan (one undo step): wall end points plus window/door jambs (or centers), linked to the walls/openings so the dimensions follow later edits. mode 'Chain' (default) = ONE chain through all given walls, measured along 'direction' (default: first wall's begin→end) — e.g. pass all walls of a facade, including the perpendicular ones whose ends should appear; mode 'EachWall' = one dimension parallel to each wall; mode 'Thickness' = one dimension ACROSS each straight wall, linked to both wall faces (shows the wall width, follows thickness changes), crossing the wall at 'thicknessPosition'. For Chain/EachWall the line is placed 'distance' m beyond the outermost wall face on 'side' ('Auto' = away from the first wall's body); 'overall' adds a second line with the total length. Get wall GUIDs first (e.g. list_elements with types ['Wall'], find_elements or get_selection). Returns {results: [{guid, role: 'chain'|'overall'|'thickness', walls, pointCount, associativePoints, segments, total, linePoint, warnings?} | {error, wall?}]}; in EachWall/Thickness mode one failing wall does not stop the others.

Changes existing dimensions in one undo step. Each item is {guid, ...fields}; only the given fields change and only fields of the dimension's type apply. Linear: move the dimension line (linePoint, or offset from the first point), change direction, replace points, pointTexts (custom segment texts), makeStatic, style (pens, markers, texts, witness lines). Level: position, element, level/static, elevationReference, marker, text. Radial: at, lineEnd, prefix, showCenter. Angle: arcPoint/radius, smallArc, line1/line2. Common: layer, storyIndex. Read the current values with get_element_details. Returns [{guid, ...summary} | {error}].

Lists the points of elements that dimensions can link to (hotspots: wall ends and corners, column corners, opening points, slab vertices, object hotspots...), with coordinates in m. Use a point's x,y with {element, x, y} in create_dimensions to create an associative point. Pass 'near' to sort by distance (and 'radius' to filter). Only anchors with usableAsPoint = true can be linked. Model elements (walls, columns, slabs, openings...) are read on the Floor Plan (plan coordinates) whatever window is active. Returns {elements: [{guid, type, anchorCount, anchors: [{x, y, z, neig, inIndex, line, special, usableAsPoint, source, distance?}]} | {error}]}.

Creates morphs (free-form 3D bodies) in one undo step. Each item needs exactly ONE geometry: 'box' {origin {x,y,z}, size {x,y,z}, rotation?}; 'extrusion' {polygon, zBottom, zTop} (prism of a plan polygon with holes/arcs); or 'mesh' {vertices: [{x,y,z}], faces: [[i,j,k,...]]} (any polyhedron; faces counter-clockwise seen from outside, planar). x/y are project coordinates, z is relative to the home story level. Closed bodies become Solid, open meshes Surface. Per-face surfaces: box/extrusion top/bottom/sideSurface, mesh face {vertices, surface}; 'surface' covers the rest. Coordinates in meters, angles in degrees, on the given story (default: current story); unspecified settings come from the tool defaults. Returns [{guid, type} | {error}] in input order. Read back with get_element_details (body counts, bounds) or get_morph_geometry; change with modify_morphs; combine with solid_operation.

Changes existing morphs in one undo step: replace the whole body (box / extrusion / mesh — e.g. edit the output of get_morph_geometry and send it back), move it (offset {x,y,z}, level), set every face's surface (faceSurface) or the default surface, building material, body/edge type, shadows and floor plan display. Only the given fields change. Returns [{guid} | {error}] in input order.

Returns the editable geometry of morphs: {elements: [{guid, bodyType, vertexCount, faceCount, vertices: [{x,y,z}], faces: [{vertices: [i,...], holes?: [{vertices}], surface?, hidden?}]}]} — the same format as the 'mesh' input of create_morphs / modify_morphs, with the morph transformation applied (x/y project coordinates, z relative to the home story). Per-item errors for non-morphs.

Creates curtain walls in one undo step along a straight ('begin'/'end') or polyline/curved ('path') base line with the Curtain Wall tool's default scheme (frame/panel classes). Set 'height', the grid (primarySpacing = module width along the wall, secondarySpacing = module height, or full primaryGrid/secondaryGrid patterns), panel surfaces/thickness and frame surface. Coordinates in meters, angles in degrees, on the given story (default: current story); unspecified settings come from the tool defaults. Returns [{guid, type} | {error}]. get_element_details lists segments, grids, frame/panel classes and the GUIDs of every frame and panel (edit single panels/frames with modify_curtain_wall_parts; change height/grid/classes with modify_curtain_walls).

Changes existing curtain walls in one undo step: height, flip, grid patterns (primaryGrid/secondaryGrid or the *Spacing shorthands), surfaces/thickness of all panel classes, surface/building material of all frame classes, zone relation, floor plan display. The base line cannot be changed (use move_elements/rotate_elements or recreate). Returns [{guid} | {error}].

Changes individual curtain wall PANELS (outer/inner/cut surface, thickness, building material, delete, class) and FRAMES (surface, building material, class) in one undo step. Setting a property customizes the part (it leaves its class) unless classId is given. Get the part GUIDs from get_element_details of the curtain wall ('panels', 'frames') or get_subelements. Returns [{guid} | {error}].

Creates stairs in one undo step from a baseline (bottom to top): 'begin'/'end' for a straight flight or a 'baseline' polyline for turning stairs (landings/winders follow the Stair tool defaults). Typical: {begin: {x:0,y:0}, end: {x:4.5,y:0}, height: 3, width: 1.2, riserCount: 17}. The baseline must be long enough for the treads (≈ (riserCount-1) × treadDepth); if Archicad rejects the geometry because of the stair rules, adjust the values or pass ignoreRules: true. Coordinates in meters, angles in degrees, on the given story (default: current story); unspecified settings come from the tool defaults. Returns [{guid, type} | {error}]. get_element_details shows riser/tread counts, pitch, baseline, boundaries and part GUIDs; add a railing along a boundary with create_railings.

Changes existing stairs in one undo step: height / top link, width, riser count/height, tread depth and locks, baseline/walking line position, direction, numbering, tread/riser thickness, rule checks. The baseline cannot be changed (move/rotate or recreate). Returns [{guid} | {error}].

Creates railings in one undo step along a reference line: 'begin'/'end' or a 'path' polyline (points may carry z to follow a slope; add arcs for curves) with the Railing tool's default posts/rails/panels. Set 'height', 'bottomOffset' and the reference line side. Coordinates in meters, angles in degrees, on the given story (default: current story); unspecified settings come from the tool defaults. Tip: to guard a stair, use its leftBoundary/rightBoundary from get_element_details as the path. Returns [{guid, type} | {error}]; get_element_details lists the segments and the GUIDs of posts, rails, handrails, panels and balusters.

Changes existing railings in one undo step: height of all segments, bottom offset, reference line side, segment offset, post offset, pens. The path cannot be changed (move/rotate or recreate). Returns [{guid} | {error}].

Returns the active Archicad window: {type: FloorPlan | 3DModel | Section | Elevation | InteriorElevation | Detail | Worksheet | Layout | MasterLayout | DocumentFrom3D | ..., database (GUID), name, reference, title, linkedElement, story {index, name, level} (floor plan), drawingScale (N of 1:N), zoom {xMin,yMin,xMax,yMax} (2D, m), projection (3D)}. Call it before capture_view/zoom to know what is shown.

Lists everything that can be opened: stories (floor plans), viewpoints (sections, elevations, interior elevations, details, worksheets, 3D documents: {type, database, name, reference, title}), layouts, and the View Map (saved views: {guid, name, id, fullName, itemType, folder, windowType, database}). Use the results with open_view (database/name) and go_to_view (guid). Names are localized (Russian).

Brings a window to the front: a floor plan story ({window:'FloorPlan', story}), the 3D window ({window:'3D', projection?}), a section/elevation/interior elevation/detail/worksheet/3D document/layout by name ({window:'Section', name:'A-A'}), by marker element ({element}), by database GUID ({database}) or by Navigator item ({navigatorItem}). Returns {opened, window}. Saved views with their layer/scale settings: go_to_view. To look at the result use capture_view.

Opens a saved view of the View Map exactly like double-clicking it in the Navigator: switches window/story and applies the view's layer combination, scale, model view options, pen set, graphic overrides and zoom. Accepts the Navigator item GUID or its name (see list_views include ['viewMap']). Project Map / Layout Book items are opened without view settings. Returns {view, method, window}.

Zooms the active window: fit (whole drawing/model), box (2D rectangle in m), elements (GUIDs), selection, in/out by a factor, previous (undo zoom) or redraw. margin adds space around 2D zooms. Returns {mode, window: {..., zoom}}. Tip: zoom {mode:'elements', elements, margin: 0.2} and then capture_view to inspect specific elements.

Returns the 3D view state: projection {mode, perspective: {camera {x,y,z}, target {x,y,z}, viewCone, roll, distance, azimuth, viewDirection, sun} | axonometric: {projection preset, azimuth, tranmat, derived view direction, sun}}, 3D style {current, available, model (Shading/HiddenLine/...), ...}, windowSize, filter {allStories, fromStory, toStory, mode (all/selection/marquee), elementTypes}, cutPlanes, rendering {scenes, imageSize} and modelExtent (3D bounding box, m). Angles in degrees.

Sets up the 3D window. Easiest overview: {mode:'perspective', azimuth: 225, altitude: 30} (camera south-west of the model, fits the whole model). Exact camera: {mode:'perspective', camera:{x,y,z}, target:{x,y,z}, viewCone}. Axonometry: {mode:'axonometric', projection:'Isometric', azimuth} or {projection:'TopView'}. Also: sun, style (3D style name), styleSettings (shading/hidden line, shadows...), windowSize, stories range, elementTypes filter, cutPlanes. Opens the 3D window unless open3D is false. Returns {changed, camera {verified, warning?} (perspective) | axonometric {viewMatrixChanged, warning?}, projection, window}. Follow with capture_view to see the result.

Shows elements in the 3D window: mode 'all' (Show All in 3D, resets a previous selection filter), 'selection' (the selected elements only) or give 'elements' (GUIDs: they get selected and only they are shown). Returns {mode, window}. Then use set_3d_view / capture_view.

Claude's eyes: saves the ACTIVE Archicad window (floor plan, section, elevation, detail, worksheet, layout or 3D) as a picture and returns it as an image. Optional preparation in the same call, in this order: goToView (saved view), view (same fields as open_view), threeD (same fields as set_3d_view; switches to 3D), zoom (same fields as zoom). 2D windows are captured as currently zoomed (use zoom {mode:'fit'} or {mode:'elements'} first); 3D captures use the 3D window size — width/height set it temporarily. Images are downscaled to maxSize (default 1600px). Examples: {view:{window:'FloorPlan', story:0}, zoom:{mode:'fit'}}; {threeD:{mode:'perspective', azimuth:225, altitude:25}}.

Photo-renders the current 3D view (camera / projection of the 3D window) with Archicad's rendering engine and returns the image. Optionally set up the camera first (threeD, same fields as set_3d_view), pick a rendering scene (names in get_3d_view rendering.scenes) and the output size (width/height px, restored afterwards). Rendering can take minutes (timeoutSeconds, default 600). For quick looks use capture_view of the 3D window instead.

Creates section markers (cut planes) on the floor plan, each with its own new section viewpoint (one undo step). Each item: begin/end of the cut line (m), viewSide (left/right of begin→end, default left), depth (limits how far the section looks), vertical range, name ('Разрез 1-1'), referenceId, storyIndex/layer. Returns [{guid, type, name, referenceId, database, begin, end, viewSide, depth} | {error}]. Open one with open_view {element: guid} and look at it with capture_view.

Creates elevation markers on the floor plan (one undo step), each with a new elevation viewpoint. begin/end = the elevation line (m) placed OUTSIDE the building, viewSide = the side the elevation looks at (towards the building), depth = how far it sees. E.g. south facade of a building spanning y 0..10: begin (-5,-5), end (20,-5), viewSide 'left' (looks north). Returns [{guid, name, database, ...}].

Creates interior elevation markers (one undo step): 'points' is a polyline inside a room along its walls; every segment becomes one interior elevation view (closed: true for all walls). depth = view depth per segment (m). If a view looks the wrong way, recreate it with the points in reverse order. Returns [{guid, name, segments: [{index, name, database}]}] — open a segment with open_view {element, segmentIndex}.

Creates detail markers (one undo step) in the current floor plan/section/elevation (or the floor plan when another window is active): the boundary polygon or box (m) defines the region copied into a new detail viewpoint; the marker is placed at markerPosition. Returns [{guid, name, referenceId, database, markerPosition, polygon}]. Open the detail with open_view {element: guid}.

Creates worksheet markers (one undo step) like create_details: boundary polygon or box (m) + marker position; each gets a new worksheet viewpoint (a 2D drafting sheet seeded with the region's drawing). Returns [{guid, name, database, ...}]. Open with open_view {element: guid}.

Without 'view': settings of the ACTIVE window — drawingScale (N of 1:N), layerCombination, penSet, structureDisplay, renovationFilter (+ available filters) and the model view option combinations matching the current options. With 'view' (View Map item GUID/name): the settings stored in that saved view (layer combination, model view options, pen set, dimension style, scale, structure display, zoom, renovation filter, graphic overrides, 3D style, rendering scene; storedInView tells which ones the view stores).

Changes view settings of the ACTIVE window (drawingScale, layerCombination, modelViewOptions, structureDisplay, renovationFilter, style3D) or — with 'view' — of a saved View Map view (additionally penSet, dimensionStyle, graphicOverrides, zoom, ignoreSavedZoom, renderingScene; the view then stores these settings). Attribute names are localized: list them with get_attributes (types LayerCombination, ModelViewOption, PenTable, DimensionStandard). Returns {changed, settings}.

Lists Archicad databases — the floor plan, sections, elevations, interior elevations, details, worksheets, 3D documents, layouts and master layouts — with databaseRef ("FloorPlan" or a guid), type, name, reference ID, title and the linked marker element. Layouts also get their Layout Book navigatorItemGuid, layoutId, master layout and sheet {width, height, margins} in meters. The databaseRef / navigatorItemGuid values are what place_drawing, get_layout_drawings, update_drawings and the export tools take. includeViews adds, per database, the View Map views that show it (navigatorItemGuid, scale) — the best sources for place_drawing. Also returns the current database/window. Names are localized (Russian Archicad).

Lists the drawings placed on layouts: guid, name, number, source view (navigatorItemGuid, name, type, link type, viewDeleted), status (UpToDate | Modified), position and bounds in PAPER meters, anchor, angle, ratio, viewScale and effective scale (denominator, e.g. 100), crop frame polygon, title, border, pen table / color mode, update mode. Default: every layout. Use it before modify_drawings / update_drawings, and to check what a layout contains.

Places views as drawings on layouts (one undo step for the batch). Each item: layout + source ('view' navigator guid — preferably a View Map view from get_databases {includeViews: true} — or 'database', e.g. a section databaseRef, or 'FloorPlan' + storyIndex), then optional position (paper meters from the sheet's bottom-left corner, default the sheet center), anchor, scale (100 = 1:100) or ratio, angle, name / number, crop frame, title, border, pen set, update mode, layer. The first target layout is brought to the front unless restoreWindow. Returns [{guid, layout, source, drawing: {position, bounds, scale, status ...}} | {error}] in input order. Create layouts with create_layout.

Changes drawings already placed on layouts (one undo step): position (paper m), anchor, angle, scale / ratio, name, number, numbering, crop frame (polygon or false), title (false or a title library part), border, pen set, color mode, update mode, layer. The source view of a drawing cannot be changed in Archicad 26 — place a new drawing and delete the old one instead. Returns [{guid, drawing} | {error}].

Deletes drawing elements from layouts (one undo step). The source views are not touched. Returns [{guid, deleted} | {error}].

Refreshes placed drawings from their source views: pass drawing guids, layouts, or all: true. Archicad 26 has no direct update call, so the connector opens each affected layout (Archicad refreshes outdated auto-update drawings when a layout is shown), temporarily switching manual-update drawings to automatic (includeManual, default true). Returns per drawing statusBefore / statusAfter (UpToDate | Modified | Unknown) and counts. Publishing a set (publish_publisher_set) also updates the drawings it contains.

Runs File > Publish for one publisher set (list them with get_publisher_sets; names are localized, e.g. '2 - Макеты'). The set's own formats apply (PDF, DWG, DXF, IFC, images, BIMx ... as configured in Archicad's Publisher). outputPath overrides the set's folder. Pass 'items' (publisher item navigator guids from get_publisher_sets {name}) to publish only those. Returns {published, outputFolder, files: [{path, sizeBytes}] written during the run, durationSeconds}. Can take minutes; Archicad is busy meanwhile.

Lists the IFC export translators of the project (localized names; the first one is Archicad's default). Use a name in export_ifc.

Saves the model as IFC (.ifc) or ifcXML (.ifcxml) with an IFC translator (default: the first/default one; see get_ifc_translators). Scope: the entire project (default), visible elements, the current story, the selection, or an explicit element list. Returns {file: {path, sizeBytes}, translator, scope, durationSeconds}. Big models can take minutes.

Exports a 2D window — floor plan story, section, elevation, detail, worksheet, 3D document or a whole layout (with its drawings and master layout) — as DXF, or DWG. The file is written from the primitives Archicad draws for every visible element, so it matches the view: lines, arcs, circles, polylines (with arcs), texts and fill pattern lines; layers = Archicad layers, colors = pen numbers, units mm by default. Line types and solid fills are not transferred (fills: fillBoundaries). A section/elevation window holds only its own 2D drafting — to get the model cut, place it on a layout and export the layout. format 'dwg' converts with the ODA File Converter (must be installed); for Archicad's own DWG translator publish a Publisher Set configured for DWG. Returns {file: {path, sizeBytes}, entityCount, counts, layerCount}.

Saves a window as PDF (Archicad's Save As PDF): a layout (sheet size from the layout), a floor plan story, section, elevation, detail, worksheet, 3D document, a View Map view, or the current front window. Batch with 'exports' (one PDF per item; common options apply to all). Page size/margins via 'paper' (meters; default: layout sheet, else A3 landscape). For many layouts in one go prefer publish_publisher_set. Returns {file: {path, sizeBytes}, exported, paper} (or results[] for a batch).

Exports 3D geometry: .obj (Wavefront, with a .mtl of surface colors/transparency next to it), .stl (binary by default, triangulated, for 3D printing / analysis) or .gsm (Archicad GDL object of the 3D window via Save as Object). Source: what the 3D window shows (default — set it up first with the views tools, e.g. show selected elements in 3D, 3D cutaway), every 3D element of the project (source 'AllElements'), explicit 'elements', or the current selection. Coordinates are project coordinates; OBJ defaults to Y-up (Blender/ three.js), STL to Z-up; units m by default. Returns {file, materialFile?, bodyCount, elementCount, vertexCount, faceCount|triangleCount, boundingBox (m, Z-up)}.

Saves elements (or the current selection) as an Archicad module file (.mod) — the file format for hotlinked modules (place_hotlink) and for merging into other projects (merge_file). All elements must be in one database (floor plan, or one section/detail/worksheet). Returns {file: {path, sizeBytes}, elementCount}.

Merges another Archicad project (.pln), archive (.pla) or module (.mod) into this project as own, editable elements (Archicad 26 has no merge API: the file is placed as a hotlinked module and the hotlink is broken). Optional placement (position m, angle deg, mirrored, home story) and story range. keepHotlink: true leaves it as a live hotlink instead. IFC / DWG / DXF cannot be merged through the API (use Archicad's File > Interoperability > Merge). Refuses files that are already hotlinked (breaking would convert those too). Returns {merged, elementCount, countsByType, elements: [guid]}. Undo: two steps (place + break).

Lists hotlink nodes — hotlinked modules (.pln/.pla/.mod) and XRefs (DWG/DXF) — as a tree: nodeGuid, name, type, source path, sourceStatus (Available | Missing | NotAccessible | ...), story range, last update, nested children, and the placed instances (guid, home story, position {x,y,z} m, angle deg, mirrored, options, optional elementCount). Use nodeGuid with place_hotlink {node}, update_hotlinks and delete_hotlinks.

Places hotlinked modules (one undo step): from a file ('source': .pln / .pla / .mod — a hotlink node is created, or an existing node with the same file and story settings is reused) or another instance of an existing node ('node' from get_hotlinks). Position/angle/mirror set where the source's origin lands; storyIndex is the home story. The module stays linked: refresh it with update_hotlinks, break it into own elements with delete_hotlinks {keepElements: true} (or use merge_file). Returns [{guid, nodeGuid, nodeCreated, instance, node} | {error}]. XRef (DWG) attachment is not available through the Archicad 26 API.

Refreshes hotlinked modules / XRefs from their source files ('nodes' or all: true — like Hotlink Manager > Update) and/or relinks nodes to another file or changes their name / story range ('relink': [{node, source?, name?, storyRange?, sourceStory?}], relinked nodes are refreshed too). Missing sources are reported with a relink hint. In Teamwork reserve the hotlink cache first (reserve_elements {objectSets: ['HotlinkCacheManagement']}). Returns per node {nodeGuid, updated|relinked, node} | {error}, updatedCount.

Removes hotlink nodes with ALL their placed instances (one undo step). keepElements: true breaks the link instead: the elements stay in the project as own, editable elements. Nested hotlinks go with their parent. Returns [{nodeGuid, name, deleted|broken, instanceCount} | {error}].

Lists property definitions — built-in (ID, areas, volumes, heights, ...) and user-defined (custom) — so you can address them in get_property_values / set_property_values. Summary per definition: {guid, name, group, type (string|integer|number|length|area|volume|angle|boolean|List|singleEnum|multiEnum), kind (Custom|BuiltIn|DynamicBuiltIn), editable, description?, expressionBased?, enumValues? (options of option sets), availabilityCount? (custom), builtInName? (language-independent name of built-ins, e.g. General_ElementID)}. detail 'full' adds groupGuid, collectionType/valueType/measureType, defaultValue or defaultExpressions, enumOptions with keys, expressionReference (for expressions) and availability (classification items). Names are LOCALIZED (Russian Archicad: Russian group and property names) — use search with a Russian word, or builtInName for built-ins. Filter with search / groups / kind, or with elements / elementTypes to get only what is available for them. Returns {definitions, total, offset, returned, hasMore, groups?}.

Creates user-defined property groups (the folders of the Property Manager) in one undo step. An existing custom group with the same name is returned with alreadyExisted: true (idempotent). create_property_definitions also creates missing groups itself. Returns {results: [{guid, name, alreadyExisted?} | {error}]}.

Renames user-defined property groups and/or changes their description (built-in groups are read-only). One undo step.

Deletes user-defined property groups in one undo step (undoable with undo). A group that still contains definitions is refused unless deleteDefinitions is true — then its definitions and all their element values are deleted too. Built-in groups cannot be deleted.

Creates user-defined (custom) properties in one undo step — like the Property Manager: any value type, option sets (singleEnum/multiEnum with enumValues), default values or expression-based defaults, and availability per classification. IMPORTANT: custom properties appear only on elements whose classification is in the availability — the default 'all' makes it available for every classification item that exists now (elements with no classification never show custom properties). Missing groups are created (createMissingGroups, default true). Then set values with set_property_values. Returns {results: [{guid, name, group, type, availabilityCount, warnings?} | {error}]} in input order.

Changes user-defined properties in one undo step: rename, move to another group, description, option set options (replace the list — unchanged options keep their identity so element values survive — or add/remove/rename options), default value or expressions, and availability (replace, add, remove, or add the classifications of given elements). Built-in properties and the value type cannot be changed (delete and recreate instead). Returns {results: [{guid, name, group, type, availabilityCount, warnings?} | {error}]}.

Deletes user-defined property definitions in one undo step — their values on ALL elements are lost (undo restores them). Built-in properties cannot be deleted. Returns {results: [{guid, name, group, type, deleted} | {error}]}.

Imports property groups and definitions from an Archicad property XML file (the Property Manager's Export format, ...). Give the XML text or a local file path. One undo step. Returns {created: [{guid, name, group, type}], groupsCreated, definitionCount}.

Reads property values (built-in and user-defined) of many elements — and/or of element TOOL DEFAULTS — as one table: {properties: [{guid, name, group, type}], results: [{guid | elementType, values: [cell per property, same order]} | {guid, error}]}. Each cell is {value, display?, isDefault?} (display = Archicad's formatted text incl. units, only when it differs from value; isDefault only for user-defined properties: true = the element has no own value and shows the default/expression) or {status: 'NotAvailable' (property not available for this element/classification) | 'NotEvaluated' | 'Undefined' (value set to Undefined) | 'Empty'}. Units: lengths m, areas m², volumes m³, angles DEGREES; option sets by display value. Without properties: every property available for the targets (scope UserDefined by default; BuiltIn/All can be hundreds). Address built-ins language-independently with {builtIn: 'General_ElementID'} etc.

Sets property values on many elements (and/or element tool defaults) in ONE undo step. Each entry sets one property on a list of elements: {elements, property, value} — or reset: true (back to the default/expression) or setUndefined: true. Works for user-defined properties and editable built-ins (e.g. {builtIn: 'General_ElementID'} = Element ID). Units: lengths m, areas m², volumes m³, angles DEGREES; option sets by display value. Fails per element (reported, others continue) when the property is not available for the element's classification (fix: modify_property_definitions {availableForElements}) or read-only (calculated / expression-based). Returns {results: [{property, guid, succeeded, failed?: [{guid|elementType, error}]} | {error}], succeeded, failed}.

Reads property values of ATTRIBUTES — mainly building materials (properties/classifications of building materials, e.g. thermal or product data) — as a table like get_property_values: {properties: [...], results: [{attribute: {type, index, name, guid}, values: [...]}]}. Each cell is {value, display?, isDefault?} (display = Archicad's formatted text incl. units, only when it differs from value; isDefault only for user-defined properties: true = the element has no own value and shows the default/expression) or {status: 'NotAvailable' (property not available for this element/classification) | 'NotEvaluated' | 'Undefined' (value set to Undefined) | 'Empty'}. Without properties: all available ones (scope UserDefined default).

Sets property values of attributes (building materials, ...) in one undo step. Each entry: {attributes: [{type, attribute}], property, value | reset: true | setUndefined: true}. The property must be available for the attribute's classification. Units: lengths m, areas m², volumes m³, angles DEGREES; option sets by display value.

Returns IFC data of elements: ifcGlobalId (22-char IFC GUID used on export), archicadIfcId, externalIfcGlobalId (elements imported from IFC), ifcType (e.g. IfcWall) and typeObjectIfcType, IFC properties grouped by property set ({propertySet, name, type Single|List|Bounded|Enumerated|Table, value/values/lower/upper/options, valueType, readOnly?}), IFC attributes (Name, Description, ObjectType, Tag, ...) and IFC classification references. Can also FIND elements by IFC GlobalId (ifcGlobalIds). Returns {elements: [{guid, ...} | {guid, error}], lookup?: [{ifcGlobalId, elements}]}.

Adds or changes IFC properties stored on elements (custom psets such as 'CC_Pset' or standard ones like Pset_WallCommon), removes stored IFC properties, sets IFC attributes (Name, Description, ObjectType, Tag, LongName, ...) and adds/removes stored IFC classification references (IfcClassificationReference) — one undo step. Property kinds: Single {value}, List {values}, Bounded {lower?, upper?}, Enumerated {values (selected), options}, Table {definingValues, definedValues}. Values are written as given (no unit conversion). Returns {properties?, attributes?, classificationReferences?} with per-entry {succeeded, failed?: [{guid, error}]} | {error}. Read back with get_ifc_data {storedOnly: true}.

Creates a classification system (like the Classification Manager's 'New'), optionally with its whole item tree, in one undo step. name + editionVersion must be unique. Items: [{id, name?, description?, children?: [...]}] (nested) — or flat with parent: ''. Then classify elements with the official classification tools and use the items in property availability. Returns {system: {guid, name, editionVersion, ...}, items: [{guid, id, path, parent?} | {id, error}], created, failed}.

Adds classification items to an existing classification system in one undo step: nested {id, name?, description?, children?} trees, under an optional parent, inserted at the end or before a sibling. Item IDs must be unique within the system. Returns {system, items: [{guid, id, path, parent?} | {id, error}], created, failed}.

Changes the ID, name and/or description of classification items in one undo step. Returns {results: [{guid, id, name?, description?} | {error}]}.

Deletes classification items together with all their children in one undo step (elements classified with them become unclassified in that system). Returns {results: [{guid, id, deleted, deletedChildren} | {error}]}.

Changes a classification system's name, editionVersion, description, source or editionDate. Returns {system}.

Deletes whole classification systems with all their items in one undo step (element classifications in them are removed). Returns {results: [{guid, name, deleted} | {error}]}.

Imports classification systems from an Archicad classification XML (Classification Manager export / downloaded systems such as Uniclass, OmniClass). Give the XML text or a local file path. One undo step. Returns {systems: [{guid, name, editionVersion, new, itemCount, ...}]}.

Teamwork (BIMcloud/BIMserver) status of the open project — call this before reserve_elements / release_elements / teamwork_send / teamwork_receive. Solo project: {isTeamwork: false, message, project: {name, path, untitled}} — then nothing needs to be reserved and the teamwork tools do nothing. Teamwork project: {isTeamwork: true, project, teamwork: {hasConnection, online, serverUrl, teamProjectName, loginName, teamProjectLocation}, currentUser: {userId, name}, members?: [{userId, loginName, fullName, connected}], hotlinkCacheManagementReservedBy?, warning? (server offline), elements?: [{guid, status: Free|ReservedByMe|ReservedByOther|ServerUnavailable|NotExist, reservedBy?: [user names]} | {error}], objectSets?: [{name, status, reservedBy?, canCreate, canDeleteModify}], accessRights?: {RightName: bool}}. Only elements with status ReservedByMe (or Free after reserving) can be modified.

Teamwork 'Send': uploads your changes to the BIMcloud/BIMserver so team members can receive them (reserved elements stay reserved). Output: {isTeamwork: true, sent: true}. In a solo (non-Teamwork) project this does nothing and returns {isTeamwork: false, message} — that is not an error: everything is editable without reservation.

Teamwork 'Receive': downloads the changes that other team members have sent, updating the local model. Output: {isTeamwork: true, received: true}. In a solo (non-Teamwork) project this does nothing and returns {isTeamwork: false, message} — that is not an error: everything is editable without reservation.

Teamwork: reserves elements and/or object sets so you can edit them (elements reserved by someone else cannot be taken; the result names the owner). Output: {isTeamwork: true, elements?: [{guid, status, reserved, conflictWith?, reservedBy?} | {error}], objectSets?: [{name, status, reserved, apiError?, conflictWith?}], warning?}. Check get_teamwork_status first. In a solo (non-Teamwork) project this does nothing and returns {isTeamwork: false, message} — that is not an error: everything is editable without reservation.

Teamwork: releases reserved elements and/or object sets so others can edit them. Archicad sends your pending changes of the released items with the release (call teamwork_send first to send everything with a comment). Output: {isTeamwork: true, elements?: [{guid, status, released} | {error}], objectSets?: [{name, status, released, apiError?}], warning?}. In a solo (non-Teamwork) project this does nothing and returns {isTeamwork: false, message} — that is not an error: everything is editable without reservation.

Lists the issues of the Issue Manager (Archicad markup entries = BCF topics). Output: {issues: [{guid, name, parentGuid?, parentName?, childIssues?, created, modified (ISO 8601 UTC), tagText, tagTextVisible, tagTextElement?, commentCount, comments?, attachedElementCounts: {creation, highlight, deletion, modification}, attachedElements?: {creation: [guid], ...}}], count, elementAttachment? ('highlighted'|'corrected' when filtered by element), total/offset/hasMore when paginated}. Issue GUIDs from here are accepted by every other issue tool.

Creates one or more issues in the Issue Manager (one undo step), optionally with comments and attached elements — use it to report problems found in the model (clashes, missing data, review notes) so the user sees them in Archicad and can export them to BCF. Output: {results: [{guid, name, comments: [commentGuid], attached?: {highlight?|creation?|deletion?|modification?: {attached: [guid], missing?, modificationPairs?}}} | {error}]} in input order.

Deletes issues (one undo step) together with their comments. By default the proposals attached as Creation/Deletion/Modification are discarded (the model stays as it is); acceptAllElements: true accepts them first. Output: {results: [{guid, name, deleted: true} | {error}]}.

Adds comments to issues (one undo step; several comments / issues per call). Output: {results: [{issue: {guid, name}, comment: {guid, author, text, status, created}} | {error}]} in input order.

Returns the comments of issues, oldest first. Output: {issues: [{guid, name, comments: [{guid, author, text, status: Error|Warning|Info|Unknown, created (ISO 8601 UTC)}]}]}.

Attaches elements to an issue (one undo step). type Highlight (default) just points at them; Creation / Deletion mark them as proposed new / to-be-deleted elements; Modification either pairs existing elements (modificationPairs: original → proposed replacement) or, with plain elements, lets Archicad create a modified copy of each. Output: {issue: {guid, name}, type, attached: [guid], missing?: [guid of non-existing elements], modificationPairs?: [{original, modified}]}.

Detaches elements from an issue whatever their attachment type (one undo step); the elements themselves are not changed. Output: {issue: {guid, name}, detached: [guid], notAttached?: [guid]}. Fails when none of them is attached (see get_issue_elements).

Returns the elements attached to issues, by attachment type. Output: {issues: [{guid, name, tagTextElement?, elements: {creation|highlight|deletion|modification: [{guid, type} | {guid, missing: true}]}}]}. Pass the GUIDs to get_element_details, select_elements or zoom tools to inspect them.

Exports issues to a BCF file (.bcfzip, BCF 2.1) for other BIM tools (Solibri, Revit, BIMcollab, ...). Output: {path, exported, issues: [{guid, name}], fileExists}.

Imports the issues (topics, comments, referenced elements) of a BCF file (.bcfzip / .bcf, BCF 2.x) into the Issue Manager without dialogs (one undo step). Elements referenced by IFC GlobalId are matched to the model. Output: {imported, issues: [...the new issues in get_issues format]}.

Lists the favorites (saved tool settings of the Favorites palette). Output: {favorites: [{name, type, variation?, folder: [..], folderPath, settings?, classifications?, categories?, properties?, notes?} | {error}], count, total/offset/hasMore when paginated}. With includeSettings the settings use the same field names as get_tool_defaults and the create_* tools. Favorite names are localized (Russian templates ship Russian names) — always take them from here. Filter by type/search/folder before using includeSettings.

Applies a favorite. target 'Defaults' (default) makes it the current settings of its tool, like double-clicking it in the Favorites palette — elements created afterwards (in Archicad or with create_* tools without explicit values) get these settings. target 'Elements' injects its settings into existing elements of the SAME type (geometry, position and story are kept). Output: {favorite, type, variation?, target, applied? (Defaults), results?: [{guid, applied: true} | {error}] (Elements), warnings?}.

Creates favorites in the Favorites palette from placed elements or from the current tool defaults (set them first with set_tool_defaults to build a favorite from scratch). Each item needs exactly one of element / toolDefaults. Output: {results: [{name, type, variation?, folder, replaced?} | {error}]} in input order. In Teamwork, reserve the 'Favorites' object set first.

Deletes favorites by exact name (placed elements are not affected). Output: {results: [{name, deleted: true} | {error}]}. In Teamwork, reserve the 'Favorites' object set first.

Renames a favorite. Output: {name, newName, renamed: true}. Fails when newName is already used.

Exports favorites to a preferences file (.prf) that other projects can import with import_favorites (or Archicad's Favorites palette). Output: {path, exported, fileExists}.

Imports favorites from a .prf file exported by Archicad / export_favorites. Output: {imported: [new names], count, firstConflict?}. In Teamwork, reserve the 'Favorites' object set first.

Returns the default settings of element tools — what the next element placed in Archicad (or created by a create_* tool without explicit values) gets. Without type/types: lists the toolbox tools {tools: [{type, variation?}], activeTool, hint}. With types: {defaults: [{type, variation?, settings: {layer, renovationStatus, drawIndex, elementId?, ...the same fields as the type's create_* tool (heights, thicknesses, structure/composite/buildingMaterial, surfaces, libraryPart, params {GDL name: value}...), gdlParameterCount?}, classifications?: [{system, systemGuid, itemGuid, itemId, itemName}], categories?: {StructuralFunction: {value, valueGuid, category}, ...}, properties?: [{guid, name, group, value | status}], notes?} | {error}]}. Use it before set_tool_defaults to see the current values and field names.

Changes the default settings of element tools (like the tool's Default Settings dialog), e.g. set the Wall tool to 3 m high 0.25 m composite walls on a given layer before drawing many walls, or prepare settings the user will draw with. Every field of the type's create_* tool can be set. Fields are applied independently: an invalid field is reported in 'rejected' without blocking the others. Output: {results: [{type, variation?, applied: [field], ignored?: [geometry fields], rejected?: [{field, error}], notes?, settings? (the resulting defaults)} | {error}]}. Save them as a favorite with create_favorite {toolDefaults: {type}}.

Read-only document revision data (Document > Issue Manager for revisions: revision issues and the layout revisions they contain). Output: {issues?: [{guid, id, description, issued, issueTime, issuedBy, overrideRevisionId, createNewRevision, visibleMarkersInIssues, customFields: {name: value}, documentRevisionCount}], documentRevisions?: [{guid, id, finalId, status: Actual|Issued, owner?, issue?: {guid, id}, layout: {id, name, databaseGuid, masterLayout, width, height, drawingScales, subsetId, subsetName, teamworkOwner?, customFields}}]}. Revision issues are NOT Issue Manager markup issues (get_issues).

Read-only Change Manager data (changes tracked for revisions, shown by change markers). Give ONE mode (default: every change of the project): documentRevision (changes in one layout revision, GUID from get_revisions), layouts / allLayouts (current revision changes of layouts), elements (changes an element belongs to) or changeIds. Output: {changes: [{id, description, lastModified, modifiedBy, issued, archived, customFields, firstIssue?}], count} | {documentRevision, changes} | {layouts: [{layout: {databaseGuid, id, name}, changes | error}]} | {elements: [{guid, changeIds, changes} | {error}]}.

Lists element GUIDs of the whole project (all stories) through the official JSON API, optionally only some types or only the current selection, with each element's type and the number of elements per type (countsByType). Returns {total, offset, returned, hasMore, countsByType, elements: [{guid, type}]}. For attribute/geometry filters (story, layer, region, ID...) use find_elements; for details of the returned elements use get_element_details, for extents get_bounding_boxes. Works without the Claude Connector add-on.

Returns the type of each element (Wall, Slab, Door, Zone, ...) — e.g. to sort GUIDs returned by other tools. Output: {elements: [{guid, type} | {guid, error}]} in input order ('Unknown' for types the official API does not name, e.g. 2D elements).

Returns axis-aligned bounding boxes of elements in project coordinates (meters): 3D boxes {xMin, yMin, zMin, xMax, yMax, zMax} (z absolute, from project zero) and/or 2D floor-plan boxes {xMin, yMin, xMax, yMax}. Also returns overall, the union of all boxes — handy to frame a view, place new elements next to existing ones, or check overlaps. Output: {elements: [{guid, box3D?, box2D?} | {guid, error}], overall3D?, overall2D?}.

For each zone (room), returns the elements that bound or belong to it (walls, columns, doors, windows, slabs, objects... as Archicad relates them), grouped by type. Output: {zones: [{zone, total, elements: {Wall: [guid...], Door: [...]}} | {zone, error}]}. Get zone GUIDs with list_elements {types: ['Zone']}. The passed GUIDs must be zones.

Lists the components of elements — the building-material parts that Archicad lists in component schedules (one per skin of a composite, per profile part, per basic structure). By default each component comes with a summary: BuildingMaterial_Name, Component_Thickness (m), Component_NetVolume / Component_GrossVolume (m³), Component_NetProjectedArea / Component_CrossSectionArea (m²). Pass properties to read other values instead, or [] for ids only. Output: {elements: [{guid, components: [{component, values: {name: value}, unavailable?: {name: status}}]} | {guid, error}]}. Use get_component_property_values to read more properties of specific components.

Reads property values of element components (building-material parts — see get_element_components): built-in quantities such as Component_Thickness, Component_NetVolume, Component_NetProjectedArea, BuildingMaterial_Name/ID/Manufacturer/Description, or any user-defined property available for components. Lengths m, areas m², volumes m³, angles degrees. Either pass components [{element, component}] or elements (= all their components). Output: {components: [{element, component, values: {property: value}, unavailable?: {property: 'notAvailable'|'notEvaluated'|'userUndefined'|error}} | {element, component, error}], propertyErrors?}.

Resolves property names to GUIDs and definitions, or searches the property catalog. Built-in properties have stable non-localized names (e.g. 'General_ElementID', 'General_Width', 'Zone_CalculatedArea', 'Component_Thickness'); user-defined ones are 'Group/Name' with localized names (e.g. 'ИНФОРМАЦИЯ О ПРОДУКТЕ/Модель'). Pass properties to resolve specific names, or browse with search (case-insensitive substring of built-in name, group or name, any language), group, propertyType and/or elements (only the properties those elements have — e.g. which user-defined properties their classification makes available). Returns [{guid, builtInName?, kind: 'BuiltIn'|'UserDefined', group, name, type, editable, description?, enumValues?, defaultValue?}]. The GUIDs work in every tool taking property references. Works without the Claude Connector add-on.

Lists the classification systems of the project (e.g. 'Классификация Archicad', Uniclass, OmniClass) with GUID, name, source, version, date and the number of items. Start here before classifying elements; then browse items with get_classification_tree.

Returns the items of a classification system as a tree ({guid, id, name?, children?}) or, with search / format 'flat', as a flat list with full paths ('Parent > Child') and depth. Item ids are what Archicad shows (localized in Russian Archicad, e.g. 'Стена', 'Перекрытие'). Use root to get one branch and maxDepth to limit large systems (childCount tells what was cut). The item GUIDs/ids are used by set_element_classifications, get_elements_by_classification and get_classification_item_details.

Returns id, name, description, full path, parent and children of classification items (by GUID, id or path). Output: {items: [{guid, id, name, description, path, system, parent?, children?} | {input, error}]}.

Returns how elements are classified in each classification system: {elements: [{guid, classifications: [{system, systemGuid, item: {guid, id, name?, path} | null (= unclassified)}]} | {guid, error}]}. Default: all systems of the project.

Classifies elements (one undo step per call handled by Archicad). Each assignment gives elements and the classification item (GUID, localized id like 'Стена' / 'Перекрытие', or path 'A > B'); item null makes the elements unclassified in that system. An element can have one item per system. Output: {results: [{guid, item?, system, ok: true} | {guid, error}]} per element. Check the result with get_element_classifications. Classification decides which user-defined properties are available for elements.

Returns the elements classified with an item (GUID, localized id or path), optionally including all sub-items of the branch. Output: {item, total, countsByType, elements: [{guid, type, item?}]}.

Shows which property definitions are available for classification items (user-defined properties appear on an element only when its classification makes them available), and/or for which classification items given properties are available. Pass items -> {items: [{item, properties: [{guid, group, name, type}]}]}; pass properties -> {properties: [{property, availableForItems: count, items: [{guid, id, path}]}]}. Change availability with modify_property_definitions {addAvailability} (properties family).

Returns a Navigator tree: Project Map (viewpoints: stories, sections, elevations, interior elevations, worksheets, details, 3D documents, 3D views, schedules, project indexes, lists), View Map (saved views, each with sourceId = its Project Map viewpoint), Layout Book (subsets, layouts with their drawings, master layouts) or a publisher set. Nodes: {id, type, prefix?, name, sourceId?, children?}. With types / nameFilter or format 'flat' you get a flat list {id, type, prefix, name, path, depth, parentId, sourceId, childCount}. The ids are used by get_navigator_items, rename/move/delete_navigator_items, clone_project_map_item_to_view_map, create_layout, get/set_layout_settings and the view/documentation tools.

Returns details of navigator items by id: type, name, prefix (ID), location (tree + path + parentId + sourceId), and type-specific data — stories: storyIndex and elevation (m); built-in folders: contents; layouts and master layouts: layoutSettings (paper size in mm, margins, numbering). Type-specific data of viewpoints is only available for Project Map items (a View Map item's sourceId is its viewpoint). Output: {items: [{id, type, ...} | {id, error}]}.

Renames a navigator item (view, View Map folder, layout, subset, viewpoint...): new name and/or new ID (the prefix shown before the name, e.g. layout number '03' or subset ID 'АР'). Pass at least one of newName / newId. The item is read back from the Layout Book / View Map / Project Map: output {ok, id, tree, prefix, name, warning?} — warning tells when Archicad kept a different name/ID (for sheet numbers of layouts prefer set_layout_settings {customLayoutNumbering: true, customLayoutNumber}). A new ID of an auto-numbered SUBSET does not last: Archicad recomputes it on the next Layout Book change. For a lasting subset ID create the subset with create_layout_subset {customNumbering: true, customNumber} and move the layouts into it (move_navigator_item).

Moves a navigator item (e.g. a view into a View Map folder, a layout into another subset) under parent, as its first child or right after the sibling after. Works inside one tree (View Map / Layout Book). Get ids with get_navigator_tree. The item is read back: output {ok, id, tree, parent, path}.

Deletes navigator items: saved views and View Map folders, layouts (with their drawings), subsets, Project Map viewpoints where Archicad allows it. This cannot be undone through this connector — check ids with get_navigator_items first. Output: {results: [{id, ok: true} | {id, error}]}.

Saves a Project Map viewpoint (story, section, elevation, detail, worksheet, 3D view, schedule, index...) as a new view in the View Map (like 'Clone a view' in the Navigator), with the current view settings. The new view can then be placed on layouts. Output: {viewId} = the new View Map item id.

Creates a folder in the View Map (to organize saved views), under parent (default: the View Map's top folder), optionally after the sibling after. Output: {folderId}. Move views into it with move_navigator_item.

Creates a layout (sheet) in the Layout Book from a master layout, inside a subset (or the Layout Book root). The paper size and margins come from the master (they are stored in the master and shared by all its layouts) — pick a master with the wanted size (see get_layout_settings on MasterLayoutItem ids from get_navigator_tree {tree: 'LayoutBook', types: ['MasterLayoutItem']}). Output: {layoutId, name, master, parent, settings, ignored?}. The layout ID/number is assigned by the subset numbering (e.g. subset '08' + own prefix 'T-' + '01' = '08T-01') unless customLayoutNumbering. New layouts are inserted as the FIRST child of the subset (reorder with move_navigator_item). Place drawings on it with the documentation tools.

Creates a subset (folder with its own numbering) in the Layout Book, under parent (subset id/name, default: root). Layout IDs in the subset are [upper prefix][own prefix][number in numberingStyle, from startAt] (e.g. ownPrefix 'A-', style '01', startAt 1 -> A-01, A-02...), or continue the previous subset's sequence. Output: {subsetId}. Check the resulting IDs with get_navigator_tree {tree: 'LayoutBook'}.

Returns the settings of layouts or master layouts: paper size (horizontalSize x verticalSize, MILLIMETERS) and margins (mm) — both defined by the master layout —, custom numbering (customLayoutNumbering, customLayoutNumber), doNotIncludeInNumbering, displayMasterLayoutBelow (meaningful on master layouts; always false on layouts), and the read-only page count (layoutPageNumber, actPageIndex) and revision state. Layouts by id or name. Output: {layouts: [{layout, name?, settings} | {layout, error}]}. Change them with set_layout_settings.

Changes settings of layouts or master layouts. Per-layout fields: customLayoutNumbering + customLayoutNumber (custom sheet ID) and doNotIncludeInNumbering. Paper size and margins (MILLIMETERS) belong to the MASTER layout: set them on a MasterLayoutItem id — or on a layout with applyToMaster: true — and every layout using that master changes. displayMasterLayoutBelow works on MasterLayoutItem ids only. Page count / page index / revision state are read-only (see get_layout_settings). Only the given fields change; the result is read back, and fields Archicad did not apply are listed in ignored. Output: {results: [{layout, type, settings, ignored?} | {layout, error}]}.

Lists the publisher sets of the project (Navigator > Publisher). With name, also returns that set's items as a flat list {id, type, name, path, sourceId} (sourceId = the View Map view or layout that is published). Publish with the documentation tools.

Browses the folder structure of an attribute type (Attribute Manager folders): a folder's GUID, its attributes {guid, name} and subfolders, recursively up to depth. Paths are arrays of folder names from the root (localized). Output: {attributeType, path, guid, attributes, subfolders: [{path, guid, attributes?, subfolders?, subfolderCount?}]}. Use the folder paths/GUIDs with create/delete/rename_attribute_folder(s) and move_attributes_to_folder; attribute details come from get_attributes.

Creates attribute folders by full path; missing parent folders are created too (e.g. ['Проект', 'Стены'] creates both). Output: {results: [{folder, guid, ok: true} | {folder, error}]}. Move attributes in with move_attributes_to_folder.

Deletes attribute folders AND every deletable attribute inside them (attributes in use or built-in ones are kept). Irreversible through this connector — inspect with get_attribute_folders first, and move attributes you want to keep out with move_attributes_to_folder. Output: {results: [{folder, ok: true} | {folder, error}]}.

Moves attributes and/or attribute folders of one type into a target folder (created beforehand with create_attribute_folders; [] = root). Attributes are given by GUID or exact localized name. Output: {ok, target, moved: {attributes, folders}}.

Renames an attribute folder (path or GUID). Output: {ok, folder: {path, guid}}.

Renders preview images (PNG) of Profile attributes (complex profiles used by walls, beams, columns, handrails...) so you can see their cross-section shape, plus each profile's name, usage and nominal size. Profiles by exact localized name or GUID (see get_attributes {type: 'Profile'} or get_attribute_folders {attributeType: 'Profile'}).

Returns the pen tables (pen sets) currently used by model views and by the layout book: {modelView: {guid, name}, layoutBook: {guid, name}}. With includePens, also their 255 pens {index, color '#RRGGBB', weight (mm), description}. Pen colors of elements follow the model-view table. Change pens with modify_pens.