Check if there is an active MM-AR session (i.e., if the user is currently logged in).

Add a new attribute to an existing class. The attribute_data must include uuid, name, attribute_type (with uuid and name of an existing AttributeType), default_value, sequence, and ui_component.

Add a new attribute to an existing SceneType (scene-level attribute, not on a class). Same structure as class attributes.

Create a new bendpoint on a relationclass instance (connection). Bendpoints add waypoints to the connection line for routing.

Create a new class (node/shape type) and add it to an existing SceneType. Use this for incremental metamodel building instead of recreating the whole SceneType.

The class_data JSON should include: uuid, name, geometry (VizRep function or null), is_reusable, is_abstract, attributes (array), and ports (array).

Create a new class instance (element/node) within a scene instance.

IMPORTANT: The API does NOT auto-create attribute instances. You MUST include them in the payload. For each attribute on the meta-Class, create an attribute_instance with:

• uuid: new UUIDv4

• name: same as meta-attribute name

• value: the desired value (or the meta-attribute's default_value)

• uuid_attribute: the meta-attribute's UUID

Example payload: { "uuid": "", "uuid_class": "", "name": "My Element", "coordinates_2d": {"x": 0, "y": 0, "z": 0}, "attribute_instance": [ { "uuid": "", "name": "Name", "value": "My Element", "uuid_attribute": "" } ] }

Create a new port (connection point) on a class. Ports define where connections can attach to an element.

Create a new port instance within a scene instance.

Create a new relationclass (edge/connection type) and add it to an existing SceneType.

IMPORTANT: The classes referenced in role_from.class_references and role_to.class_references MUST already exist in the SceneType.

The relationclass_data JSON should include: uuid, name, geometry, role_from (with uuid, name, class_references[{uuid, min, max}]), role_to (same structure), bendpoint, attributes, ports.

Create a new relationclass instance (connection/edge) within a scene instance.

Include:

• uuid, uuid_class, uuid_relationclass (all set to the meta-Relationclass UUID)

• role_instance_from: { uuid, uuid_role, uuid_has_reference_class_instance }

• role_instance_to: { uuid, uuid_role, uuid_has_reference_class_instance }

• attribute_instance: [...] (for each attribute on the meta-Relationclass)

line_points are AUTO-POPULATED from source/target coordinates — you do NOT need to provide them.

Create a new model instance (diagram) for a specific SceneType. The scene_instance_data should be a JSON object with at minimum: uuid (generate a new UUID v4), name, and optionally class_instances, relationclasses_instances, role_instances, attribute_instances, and port_instances arrays.

Create a complete modeling language (SceneType) in MM-AR in a SINGLE atomic transaction. This is the primary way to create metamodels.

IMPORTANT RULES:

1. Pre-generate ALL UUIDs (v4) for every object in the payload (SceneType, Classes, Attributes, RelationClasses, Roles).

2. Call mmar_list_attribute_types FIRST to get AttributeType UUIDs (e.g., String, Float).

3. Classes are created BEFORE RelationClasses — role class_references must point to class UUIDs in the same payload.

4. Duplicate UUID → 409 CONFLICT.

5. The entire operation is atomic — all or nothing.

The scene_type_data JSON must follow this structure: { "uuid": "", "name": "My Language", "description": "...", "classes": [{ uuid, name, geometry, attributes: [{ uuid, name, attribute_type: { uuid, name }, default_value, sequence }], ports: [] }], "relationclasses": [{ uuid, name, geometry, role_from: { uuid, name, class_references: [{ uuid, min, max }] }, role_to: { uuid, name, class_references: [{ uuid, min, max }] }, attributes: [], ports: [] }], "attributes": [], "ports": [], "procedures": [] }

Delete a specific attribute instance by its UUID.

Delete a specific bendpoint from a connection by its UUID.

Delete a class (node type) from a metamodel permanently. This also removes its attributes, ports, and any role references to it.

Delete a specific class instance (element/node) from a diagram by its UUID.

Delete a specific port instance by its UUID.

Delete a relationclass (edge type) from a metamodel permanently. This also removes its roles, attributes, and ports.

Delete a specific relationclass instance (connection/edge) from a diagram by its UUID.

Delete a specific model instance (diagram) and all its contents by UUID.

Delete a modeling language (SceneType) and ALL its contents (classes, relationclasses, attributes, etc.) permanently. This cannot be undone.

Get the full details of a specific meta-attribute by UUID. Returns the attribute definition including its type, default value, sequence, and UI component.

Get the full details of a specific attribute instance by its UUID. Returns the attribute value, type reference, and which element it belongs to.

Get all attribute instances for a specific class instance (element).

Get all attribute instances for a specific relationclass instance (connection).

Get full details of a specific attribute type by UUID. Returns the type definition including its regex validation pattern, name, and description.

Get all bendpoint instances for a specific relationclass instance (connection). Bendpoints define intermediate waypoints on a connection line.

Get the full details of a specific class (node type) by its UUID. Returns the class with its attributes, ports, and geometry (VizRep).

Get all classes (node/shape types) defined in a specific modeling language (SceneType). Classes represent the elements that can be placed on a diagram.

Get the full details of a specific class instance (element/node) by its UUID. Returns the class instance with its attribute instances, port instances, and position.

Get all class instances (elements/nodes) within a specific scene instance (diagram).

Get the full details of a specific port by UUID. Ports are connection points on classes.

Get the full details of a specific port instance by its UUID.

Get all port instances within a specific scene instance.

Get the full details of a specific relation type (edge type) by its UUID. Returns the relationclass with its role_from, role_to, attributes, and connection rules.

Get all relation types (edge/connection types) defined in a specific modeling language (SceneType). Relationclasses define how elements can be connected to each other, including their roles (source/destination rules).

Get the full details of a specific relationclass instance (connection/edge) by its UUID.

Get all relationclass instances (connections/edges) within a specific scene instance (diagram).

Get the full details of a specific role by UUID. Returns the role definition including its class_references (which classes it can connect to), port_references, and cardinality (min/max).

Get the source (from) role instance of a specific relationclass instance.

Get the full details of a specific role instance by its UUID. Returns the role instance with its class instance reference and cardinality.

Get the destination (to) role instance of a specific relationclass instance.

Get the full details of a specific model instance (diagram) by its UUID. Returns the complete SceneInstance including all class instances, relationclass instances, attribute instances, role instances, and port instances.

Get the full details of a specific modeling language (SceneType) by its UUID. Returns the complete SceneType including all its classes, relationclasses, attributes, ports, and roles.

List all available attribute types in MM-AR (e.g., String, Float, Integer, Boolean, Enumeration, Table). These are the primitive data types that attributes can use. You MUST know these UUIDs before creating attributes on classes or relationclasses.

List all model instances (diagrams) for a specific modeling language (SceneType). Returns an array of SceneInstance objects with their UUIDs, names, and content.

List all available modeling languages (SceneTypes) in MM-AR. Each SceneType defines a modeling language with its classes, relations, and rules. Returns an array of SceneType objects with their UUIDs and names.

Log in to the MM-AR metamodeling platform. This MUST be called first before using any other MM-AR tools. Returns a confirmation that the session is active.

Log out from the MM-AR platform by clearing the stored session token.

Update an existing meta-attribute. Send the updated attribute data including name, default_value, sequence, ui_component, and attribute_type.

Update the value of an attribute instance. Use this to change data values on elements (e.g., setting a name, description, or any custom attribute).

Update an existing bendpoint. Use this to change the waypoint position.

Update an existing class (node type). Send the complete desired state — the server will diff and apply changes to attributes, ports, and other properties.

Update an existing class instance. Send the complete desired state including position, attribute instances, etc.

Update an existing port. Send the complete desired state of the port.

Update an existing port instance. Send the complete desired state.

Update an existing relationclass (edge type). Send the complete desired state — the server will diff and apply changes to roles, attributes, and other properties.

Update an existing relationclass instance (connection/edge). Send the complete desired state.

Update an existing role on a relationclass. Use this to change cardinality (min/max) or which classes a role can connect to (class_references). Send the complete desired state of the role.

Update an existing role instance. Use this to change which class instance a connection endpoint references.

Update an existing model instance (diagram). Uses smart diffing — new elements are added, existing ones updated.

IMPORTANT: This is the RECOMMENDED way to add connections (relationclass instances). Include uuid_scene_type in the payload. New relationclasses_instances entries will be created.

The payload must include at minimum: uuid, name, uuid_scene_type. Add relationclasses_instances array with connection objects including role_instance_from/to.

Update an existing modeling language (SceneType). Uses smart diff-based updates by default — new children are added, existing ones are updated.

Set hardpatch=true for FULL REPLACEMENT mode: children not in the payload will be DELETED. Use with caution.

Send the complete desired state of the SceneType (same structure as mmar_create_scene_type).