Python API methods

Public methods exposed by the current Tech Connector Python API, engine runtime API, and asset editor API. Use api.surface() in your installed build for the live signature inventory; access may depend on your license and configuration.

Engine entries use TCEngineAPI from tech_connector.game_engine.runtime.tc_engine_api and editor = TCEditorAPI(project_root) from tech_connector.game_engine.assets.editor_python_api.

Core

14 public methods.

1. call_function
2. cancel_llm_request
3. capabilities
4. describe
5. dry_run_prompt
6. entitlement_status
7. execute_action_graph
8. execute_prompt_chain
9. generate_pipeline_from_prompt
10. llm_queue_status
11. plan_prompt
12. plan_prompt_chain
13. surface
14. verify_license

api.call_function(entry_point: str, *args: Any, kwargs: dict[str, Any] | None=None, extra_roots: list[str] | None=None, stamp_project_provenance: bool=False) -> APIResult

api.cancel_llm_request(request_id: str, reason: str='Cancelled by API request.') -> bool

api.capabilities() -> dict[str, Any]

api.describe(feature_id: str='', operation: str='') -> dict[str, Any]

api.dry_run_prompt(prompt: str) -> dict[str, Any]

api.entitlement_status() -> dict[str, Any]

api.execute_action_graph(graph: dict[str, Any], *, approved: bool=False, dry_run: bool=False, policy: dict[str, Any] | None=None) -> dict[str, Any]

api.execute_prompt_chain(prompts: str | list[str] | tuple[str, ...], *, approved: bool=False, dry_run: bool=False, stop_on_error: bool=True, policy: dict[str, Any] | None=None, project_roots: list[str] | None=None) -> APIResult

api.generate_pipeline_from_prompt(prompt: str, *, name: str='headless_pipeline', stamp_provenance: bool=True) -> APIResult

api.llm_queue_status() -> dict[str, Any]

api.plan_prompt(prompt: str, *, project_roots: list[str] | None=None) -> dict[str, Any]

api.plan_prompt_chain(prompts: str | list[str] | tuple[str, ...], *, project_roots: list[str] | None=None) -> dict[str, Any]

api.surface() -> dict[str, Any]

api.verify_license() -> dict[str, Any]

Ai

5 public methods.

1. benchmark_local
2. generate
3. local_recommendation
4. models
5. route

api.ai.benchmark_local(*, model: str='', prompt: str='', num_predict: int=128, num_ctx: int=4096, timeout: int=300) -> APIResult

api.ai.generate(prompt: str, *, system: str='', model: str='', depth: str='balanced', response_format: dict[str, Any] | str | None=None, options: dict[str, Any] | None=None, timeout: int=120, allow_local_fallback: bool=False) -> APIResult

api.ai.local_recommendation() -> APIResult

api.ai.models() -> APIResult

api.ai.route(*, model: str='', depth: str='balanced') -> APIResult

Reasoning

7 public methods.

1. capabilities
2. execute_tool
3. prepare
4. run
5. run_chain
6. snapshot
7. tools

api.reasoning.capabilities() -> dict[str, Any]

api.reasoning.execute_tool(tool_name: str, arguments: dict[str, Any] | None=None, *, approved: bool=False, dry_run: bool=False) -> APIResult

api.reasoning.prepare(prompt: str, *, context: dict[str, Any] | None=None) -> APIResult

api.reasoning.run(prompt: str, *, context: dict[str, Any] | None=None, progress_callback: Callable[[dict[str, Any]], None] | None=None, activity_callback: Callable[[dict[str, Any]], None] | None=None) -> APIResult

api.reasoning.run_chain(prompts: str | list[str] | tuple[str, ...], *, context: dict[str, Any] | None=None, stop_on_error: bool=True, progress_callback: Callable[[dict[str, Any]], None] | None=None, activity_callback: Callable[[dict[str, Any]], None] | None=None) -> APIResult

api.reasoning.snapshot(prompt: str='', *, context: dict[str, Any] | None=None) -> APIResult

api.reasoning.tools() -> APIResult

Features

7 public methods.

1. describe
2. get
3. invoke
4. list
5. manifest
6. register
7. search

api.features.describe(feature_id: str, operation: str='') -> dict[str, Any]

api.features.get(feature_id: str) -> dict[str, Any]

api.features.invoke(feature_id: str, operation: str, **kwargs: Any) -> APIResult

api.features.list(*, category: str='', available_only: bool=True, access: str='', lifecycle_stage: str='', owner_feature_id: str='') -> list[dict[str, Any]]

api.features.manifest() -> dict[str, Any]

api.features.register(descriptor: APIFeatureDescriptor, handlers: dict[str, Callable[..., Any]] | None=None, *, replace: bool=False) -> None

api.features.search(query: str, *, category: str='', available_only: bool=True) -> list[dict[str, Any]]

Integrations

7 public methods.

1. applications
2. dispatch
3. oauth_url
4. resolve
5. status
6. suggest
7. targets

api.integrations.applications() -> APIResult

api.integrations.dispatch(text: str, *, default_title: str='Tech Connector Output', approved: bool=False, dry_run: bool=False) -> APIResult

api.integrations.oauth_url(provider: str, *, client_id: str='', redirect_uri: str='') -> APIResult

api.integrations.resolve(text: str) -> APIResult

api.integrations.status(account_id: str='') -> APIResult

api.integrations.suggest(query: str='', *, active_hosts: Iterable[str]=(), limit: int=20) -> APIResult

api.integrations.targets(provider: str, *, refresh: bool=False) -> APIResult

Dcc

5 public methods.

1. aliases
2. catalog
3. host
4. native_catalog
5. reference_search

api.dcc.aliases() -> dict[str, dict[str, str]]

api.dcc.catalog() -> dict[str, Any]

api.dcc.host(host: str) -> DccHostAPINamespace

api.dcc.native_catalog(host: str, namespace: str='', *, limit: int=0) -> APIResult

api.dcc.reference_search(query: str, *, host: str='', limit: int=50) -> dict[str, Any]

Dcc Host

5 public methods.

1. aliases
2. call
3. execute_python
4. native_catalog
5. resolve

api.dcc.<host>.aliases() -> dict[str, str]

api.dcc.<host>.call(name: str, *args: Any, kwargs: dict[str, Any] | None=None, **options: Any) -> APIResult

api.dcc.<host>.execute_python(source: str, *, timeout: float=30.0) -> APIResult

api.dcc.<host>.native_catalog(namespace: str='', *, limit: int=0) -> APIResult

api.dcc.<host>.resolve(name: str) -> str

Kingdom

25 public methods.

This count covers the direct facade. The project editor declares additional operations through api.kingdom.editor_capabilities(); inspect a signature with editor_describe() and invoke a declared operation with editor_call().

1. access_contract
2. audit_runtime
3. capability_report
4. code_to_graph
5. compile_graph
6. configure_runtime
7. create_character
8. create_effect
9. create_game_experience
10. create_graph_runtime
11. create_presentation
12. decide_character
13. editor_call
14. editor_capabilities
15. editor_describe
16. execute_graph
17. execute_world_intelligence
18. graph_to_code
19. plan_playtest
20. preview_presentation
21. qualify_runtime
22. solve_grounded_animation
23. step_vehicle
24. update_running_game
25. validate_game_experience

api.kingdom.access_contract() -> APIResult

api.kingdom.audit_runtime(runtime: Any, *, determinism_receipt: dict[str, Any] | None=None, minimum_performance_samples: int=30) -> APIResult

api.kingdom.capability_report() -> APIResult

api.kingdom.code_to_graph(source_code: str, previous: Any=None) -> APIResult

api.kingdom.compile_graph(program_or_manifest: Any) -> APIResult

api.kingdom.configure_runtime(world: Any, *, target: str='desktop', goal: str='balanced', quality: str='auto', backend: str='auto', adaptive: bool=True, tick_rate: int | None=None) -> APIResult

api.kingdom.create_character(world: Any, profile: Any) -> APIResult

api.kingdom.create_effect(preset: str, *, target: str='desktop', goal: str='balanced', quality: str='auto', seed: int=1) -> APIResult

api.kingdom.create_game_experience(profile_id: str, game_types: Any, **options: Any) -> APIResult

api.kingdom.create_graph_runtime(program_or_manifest: Any, context: Any, **options: Any) -> APIResult

api.kingdom.create_presentation(profile_id: str, visual_style: str, **options: Any) -> APIResult

api.kingdom.decide_character(world: Any, character_id: str, actions: Any, *, available_affordances: Any=(), now: float=0.0, model_proposal: Any=None) -> APIResult

api.kingdom.editor_call(operation: str, **kwargs: Any) -> APIResult

api.kingdom.editor_capabilities() -> APIResult

api.kingdom.editor_describe(operation: str='') -> APIResult

api.kingdom.execute_graph(program_or_manifest: Any, context: Any, **options: Any) -> APIResult

api.kingdom.execute_world_intelligence(world: Any, runtime_state: Any, command: str, **payload: Any) -> APIResult

api.kingdom.graph_to_code(program: Any) -> APIResult

api.kingdom.plan_playtest(*, target: str='desktop', session_mode: str='play_in_editor', changed_modes: list[str] | tuple[str, ...]=(), session_connected: bool=False) -> APIResult

api.kingdom.preview_presentation(profile: Any, **options: Any) -> APIResult

api.kingdom.qualify_runtime(runtime: Any, *, ticks: int=30, repeats: int=2, minimum_performance_samples: int=30) -> APIResult

api.kingdom.solve_grounded_animation(runtime: Any, limb_settings: Any, bone_positions: Any, ground_query: Any, **options: Any) -> APIResult

api.kingdom.step_vehicle(runtime: Any, wheels: Any, chassis_position: Any, chassis_velocity: Any, controls: Any, ground_query: Any, **options: Any) -> APIResult

api.kingdom.update_running_game(scene_document: Any, scene_path: str | Path, *, force_full: bool=False) -> APIResult

api.kingdom.validate_game_experience(profile: Any) -> APIResult

Garden

10 public methods.

The Garden method count covers the high-level facade. Browse all registered scene commands. Use api.garden.search() and api.garden.describe() to discover them; live execution requires an active viewer.

1. active_viewer
2. commands
3. describe
4. execute_active
5. register_active_viewer
6. route
7. search
8. target
9. target_from_proxy
10. unregister_active_viewer

api.garden.active_viewer() -> APIResult

api.garden.commands() -> APIResult

api.garden.describe(command: str) -> APIResult

api.garden.execute_active(command: str, **kwargs: Any) -> APIResult

api.garden.register_active_viewer(viewer: Any) -> APIResult

api.garden.route(command: str, command_target: Any, **kwargs: Any) -> APIResult

api.garden.search(query: str='', *, department: str='', limit: int=50) -> APIResult

api.garden.target(*args: Any, **kwargs: Any) -> APIResult

api.garden.target_from_proxy(*args: Any, **kwargs: Any) -> APIResult

api.garden.unregister_active_viewer(viewer: Any) -> APIResult

Ophanim

5 public methods.

These methods cover opening and capture. Browse the desktop image editor tools; those tools are not individual headless API methods.

1. actions
2. capture_and_open
3. capture_viewport
4. invoke
5. open_image

api.ophanim.actions() -> APIResult

api.ophanim.capture_and_open(dcc_name: str='Autodesk Maya') -> APIResult

api.ophanim.capture_viewport(dcc_name: str='Autodesk Maya', *, as_data_url: bool=True, return_path: bool=False) -> APIResult

api.ophanim.invoke(action: str, *args: Any, kwargs: dict[str, Any] | None=None) -> APIResult

api.ophanim.open_image(image_path: str='', *, show: bool=True) -> APIResult

Ui

3 public methods.

1. actions
2. catalog
3. invoke

api.ui.actions() -> APIResult

api.ui.catalog() -> APIResult

api.ui.invoke(action: str, *args: Any, **kwargs: Any) -> APIResult

Engine Runtime

21 public methods.

1. audit_runtime
2. code_to_graph
3. compile_graph
4. configure_runtime
5. create_character
6. create_effect
7. create_game_experience
8. create_graph_runtime
9. create_presentation
10. decide_character
11. editor
12. execute_graph
13. execute_world_intelligence
14. graph_to_code
15. plan_playtest
16. preview_presentation
17. qualify_runtime
18. solve_grounded_animation
19. step_vehicle
20. update_running_game
21. validate_game_experience

TCEngineAPI.audit_runtime(runtime: SimulationRuntimeInstance, *, determinism_receipt: dict[str, Any] | None=None, minimum_performance_samples: int=30) -> dict[str, Any]

TCEngineAPI.code_to_graph(source_code: str, previous: Any=None) -> Any

TCEngineAPI.compile_graph(program: Any) -> dict[str, Any]

TCEngineAPI.configure_runtime(world: Any, *, target: str='desktop', goal: str='balanced', quality: str='auto', backend: str='auto', adaptive: bool=True, tick_rate: int | None=None) -> ConfiguredRuntime

TCEngineAPI.create_character(world: Any, profile: Any) -> Any

TCEngineAPI.create_effect(cls, preset: str, *, target: str='desktop', goal: str='balanced', quality: str='auto', seed: int=1) -> ConfiguredRuntime

TCEngineAPI.create_game_experience(profile_id: str, game_types: Any, **options: Any) -> Any

TCEngineAPI.create_graph_runtime(program_or_manifest: Any, context: Any, **options: Any) -> Any

TCEngineAPI.create_presentation(profile_id: str, visual_style: str, **options: Any) -> Any

TCEngineAPI.decide_character(world: Any, character_id: str, actions: Any, *, available_affordances: Any=(), now: float=0.0, model_proposal: Any=None) -> Any

TCEngineAPI.editor(project_root: str | Path, **options: Any) -> Any

TCEngineAPI.execute_graph(program_or_manifest: Any, context: Any, **options: Any) -> Any

TCEngineAPI.execute_world_intelligence(world: Any, runtime_state: Any, command: str, **payload: Any) -> dict[str, Any]

TCEngineAPI.graph_to_code(program: Any) -> str

TCEngineAPI.plan_playtest(*, target: str='desktop', session_mode: str='play_in_editor', changed_modes: list[str] | tuple[str, ...]=(), session_connected: bool=False) -> dict[str, Any]

TCEngineAPI.preview_presentation(profile: Any, **options: Any) -> dict[str, Any]

TCEngineAPI.qualify_runtime(runtime: SimulationRuntimeInstance, *, ticks: int=30, repeats: int=2, minimum_performance_samples: int=30) -> dict[str, Any]

TCEngineAPI.solve_grounded_animation(runtime: Any, limb_settings: Any, bone_positions: Any, ground_query: Any, **options: Any) -> Any

TCEngineAPI.step_vehicle(runtime: Any, wheels: Any, chassis_position: Any, chassis_velocity: Any, controls: Any, ground_query: Any, **options: Any) -> Any

TCEngineAPI.update_running_game(scene_document: Any, scene_path: str | Path, *, force_full: bool=False) -> dict[str, Any]

TCEngineAPI.validate_game_experience(profile: Any) -> dict[str, Any]

Engine Editor

261 public methods.

1. add_ocean_wake
2. add_sequence_binding
3. add_sequence_folder
4. add_sequence_key
5. add_sequence_section
6. add_sequence_track
7. animation_properties
8. apply_effect_preset
9. apply_material_preset
10. apply_prefab_overrides
11. asset_conversion_coverage
12. asset_dependency_graph
13. asset_revision_history
14. asset_source_control_history
15. asset_source_control_status
16. assign_geometry_optimization_profile
17. assign_material_texture
18. assign_skin_binding
19. audio_clip_settings
20. audit_launch_readiness
21. auto_map_ik_retargeter
22. auto_setup_cloth
23. auto_setup_ik_rig
24. auto_setup_physics_asset
25. available_game_quality_profiles
26. available_game_templates
27. begin_gameplay_class_debug_session
28. build_physics_stress_scene
29. build_world_backend
30. cancel_asset_import
31. capability_contract
32. capability_report
33. compile_gameplay_class
34. compile_shader_graph
35. compile_world_asset
36. content_browser_assets
37. content_browser_collections
38. content_browser_reference_health
39. content_browser_search_help
40. convert_animation_export_file
41. convert_live_unity_animation
42. convert_live_unreal_animation
43. convert_unity_animation
44. convert_unity_audio
45. convert_unity_effects
46. convert_unity_scriptable_objects
47. convert_unreal_animation
48. convert_unreal_audio
49. convert_unreal_data_assets
50. convert_unreal_effects
51. cook
52. cook_animation_asset
53. cook_audio_asset
54. cook_behavior_graph
55. cook_character_asset
56. cook_cloth
57. cook_effect_system
58. cook_gameplay_foundation_asset
59. cook_geometry_optimization
60. cook_groom
61. cook_image_project
62. cook_level_sequence
63. cook_locomotion_controller
64. cook_material
65. cook_physics
66. cook_prefab
67. cook_procedural_graph
68. cook_procedural_tasks
69. cook_rig_asset
70. cook_ui_document
71. create_animation_clip
72. create_animation_controller
73. create_animation_mask
74. create_asset
75. create_audio_attenuation
76. create_audio_mixer
77. create_audio_reverb
78. create_behavior
79. create_blend_space
80. create_character_definition
81. create_cloth
82. create_component_archetype
83. create_control_rig
84. create_data_schema
85. create_data_table
86. create_effect_system
87. create_enum
88. create_fabric_material
89. create_game_project_from_template
90. create_gameplay_class
91. create_gameplay_graph
92. create_geometry_optimization_profile
93. create_groom
94. create_groom_binding
95. create_hair_material
96. create_ik_retargeter
97. create_ik_rig
98. create_image_project
99. create_level_sequence
100. create_locomotion_controller
101. create_material
102. create_material_instance
103. create_ocean_surface
104. create_physics_asset
105. create_physics_constraint
106. create_prefab
107. create_prefab_variant
108. create_procedural_graph
109. create_project_settings
110. create_runtime_physics_joint
111. create_runtime_soft_body
112. create_shader_graph
113. create_skeletal_mesh_asset
114. create_skeleton
115. create_skin_binding
116. create_sound_cue
117. create_starter_character
118. create_struct
119. create_typed_data_asset
120. create_ui_document
121. create_world_asset
122. debug_gameplay_class
123. delete_content_browser_collection
124. delete_level_actors
125. duplicate_level_actors
126. edit_runtime_physics_joints
127. effect_module_library
128. effect_presets
129. effect_properties
130. end_gameplay_class_debug_session
131. estimate_effect_cost
132. evaluate_animation_controller
133. evaluate_blend_space
134. evaluate_level_sequence
135. execute_behavior_graph
136. execute_bulk_asset_operation
137. export_animation_interchange
138. export_assets
139. flatten_image_project
140. gameplay_class_debug_command
141. generate_character_lods
142. generate_groom_lods
143. generate_mesh_lod_geometry
144. generate_ocean_patch
145. generate_runtime_ragdoll
146. get_level_sequence
147. get_procedural_graph
148. get_world_asset
149. import_animation_interchange
150. import_asset
151. import_procedural_native_document
152. input_map_audit
153. instantiate_prefab
154. isolate_level_actors
155. level_actors
156. level_sequence_render_jobs
157. list_gameplay_class_debug_sessions
158. material_graph_statistics
159. material_presets
160. move_level_actors_to_folder
161. open_world_streaming_runtime
162. paint_foliage
163. paint_terrain_layer
164. parent_level_actors
165. perforce_asset_action
166. perforce_changelists
167. plan_asset_reference_replacement
168. plan_bulk_asset_operation
169. plan_geometry_optimization
170. plan_navigation_rebuild
171. preview_ui_document
172. preview_world_asset
173. procedural_diagnostics
174. procedural_execution_plan
175. procedural_native_document
176. procedural_operation_catalog
177. process_asset_import_queue
178. project_groom_binding
179. properties
180. qualify_capability_evidence
181. qualify_content_browser
182. qualify_content_production
183. qualify_dcc_release
184. qualify_playable_project
185. qualify_realtime_fx
186. qualify_world_production
187. query_navigation_path
188. queue_asset_imports
189. reimport_asset
190. remove_runtime_physics_joint
191. remove_sequence_section
192. remove_sequence_track
193. reorder_level_actor_component
194. repair_content_browser_references
195. replace_asset_references
196. reset_procedural_simulation
197. resolve_data_schema
198. resolve_gameplay_class
199. resolve_material
200. resolve_prefab
201. revert_material_instance_overrides
202. revert_prefab_overrides
203. sample_ocean_surface
204. save_content_browser_collection
205. save_level_camera_bookmark
206. sculpt_terrain
207. sequence_binding
208. sequence_folder
209. sequence_from_unity
210. sequence_from_unreal
211. sequence_key
212. sequence_level_blend
213. sequence_section
214. sequence_to_unity
215. sequence_to_unreal
216. sequence_track
217. set_animation_properties
218. set_audio_clip_settings
219. set_cloth_map
220. set_effect_properties
221. set_level_actor_lock
222. set_level_actor_render_mesh
223. set_level_actor_visibility
224. set_material_instance_overrides
225. set_procedural_graph
226. set_properties
227. set_texture_import_settings
228. shader_backend_capabilities
229. show_all_level_actors
230. step_procedural_simulation
231. texture_import_settings
232. transform_level_actors
233. transform_sequence_keys
234. update_character_asset
235. update_input_map
236. update_level_sequence
237. update_ui_document
238. update_world_asset
239. validate_animation_asset
240. validate_audio_asset
241. validate_behavior_graph
242. validate_character_asset
243. validate_cloth
244. validate_effect_system
245. validate_gameplay_class
246. validate_gameplay_foundation_asset
247. validate_geometry_optimization
248. validate_groom
249. validate_image_project
250. validate_level_sequence
251. validate_locomotion_controller
252. validate_material
253. validate_physics
254. validate_playable_project
255. validate_prefab
256. validate_procedural_graph
257. validate_rig_asset
258. validate_shader_graph
259. validate_ui_document
260. validate_world_asset
261. world_asset_visualization

editor.add_ocean_wake(ocean: OceanSurface, position: Sequence[float], velocity: Sequence[float], *, radius: float=1.0, strength: float=0.25, lifetime: float=6.0) -> dict[str, Any]

editor.add_sequence_binding(asset_id: str, name: str, **target: Any) -> dict[str, Any]

editor.add_sequence_folder(asset_id: str, name: str, *, parent_id: str='') -> dict[str, Any]

editor.add_sequence_key(asset_id: str, track_id: str, section_id: str, channel_name: str, frame: float, value: Any, *, interpolation: str='linear', in_tangent: float=0.0, out_tangent: float=0.0) -> dict[str, Any]

editor.add_sequence_section(asset_id: str, track_id: str, name: str, start_frame: int, end_frame: int, *, referenced_asset_id: str='', row: int=0) -> dict[str, Any]

editor.add_sequence_track(asset_id: str, track_type: str, name: str='', *, binding_id: str='', parent_id: str='') -> dict[str, Any]

editor.animation_properties(asset_id: str) -> dict[str, Any]

editor.apply_effect_preset(asset_id: str, preset: str, *, preserve_parameters: bool=True) -> dict[str, Any]

editor.apply_material_preset(asset_id: str, preset: str) -> dict[str, Any]

editor.apply_prefab_overrides(asset_id: str, overrides: Mapping[str, Any], *, paths: Sequence[str]=()) -> dict[str, Any]

editor.asset_conversion_coverage() -> dict[str, Any]

editor.asset_dependency_graph(asset_id: str, *, include_referencers: bool=True, max_depth: int=32) -> dict[str, Any]

editor.asset_revision_history(asset_id: str, *, limit: int=50) -> tuple[dict[str, Any], ...]

editor.asset_source_control_history(asset_id: str, *, limit: int=25) -> tuple[dict[str, Any], ...]

editor.asset_source_control_status(asset_ids: Iterable[str]) -> dict[str, dict[str, Any]]

editor.assign_geometry_optimization_profile(skeletal_mesh_id: str, profile_id: str) -> dict[str, Any]

editor.assign_material_texture(asset_id: str, slot: str, texture_asset_id: str, *, channel: str='rgba', color_space: str='auto', sampler: str='linear_wrap', uv_set: int=0) -> dict[str, Any]

editor.assign_skin_binding(skeletal_mesh_id: str, skin_binding_id: str) -> dict[str, Any]

editor.audio_clip_settings(asset_id: str) -> dict[str, Any]

editor.audit_launch_readiness(*, production: bool=False) -> dict[str, Any]

editor.auto_map_ik_retargeter(asset_id: str) -> list[dict[str, Any]]

editor.auto_setup_cloth(asset_id: str, vertex_count: int, *, fixed_vertices: Iterable[int]=(), transition_vertices: Mapping[int, float] | None=None, max_distance: float=1.0) -> dict[str, Any]

editor.auto_setup_ik_rig(asset_id: str, bones: Iterable[Mapping[str, Any] | str]) -> list[dict[str, Any]]

editor.auto_setup_physics_asset(asset_id: str, joints: Mapping[str, Mapping[str, Any]], *, root_joint: str='', preset: str | None=None, include_leaf_joints: bool=False) -> dict[str, Any]

editor.available_game_quality_profiles() -> tuple[dict[str, Any], ...]

editor.available_game_templates() -> tuple[dict[str, Any], ...]

editor.begin_gameplay_class_debug_session(asset_id: str, *, instance_id: str='EditorPreview', session_id: str='', context: Mapping[str, Any] | None=None, breakpoints: Sequence[str]=(), watches: Sequence[str]=(), execution_mode: str='editor_simulation', selected_entity_id: str='') -> dict[str, Any]

editor.build_physics_stress_scene(scenario: str, *, count: int=1000) -> dict[str, Any]

editor.build_world_backend(asset_id: str, *, platform: str='desktop', quality: str='high') -> dict[str, Any]

editor.cancel_asset_import(queue_id: str) -> bool

editor.capability_contract() -> dict[str, Any]

editor.capability_report() -> dict[str, Any]

editor.compile_gameplay_class(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.compile_shader_graph(asset_id: str, *, target: str='desktop') -> dict[str, Any]

editor.compile_world_asset(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.content_browser_assets(*, query: str='', collection: str='') -> tuple[dict[str, Any], ...]

editor.content_browser_collections() -> tuple[dict[str, Any], ...]

editor.content_browser_reference_health() -> dict[str, Any]

editor.content_browser_search_help() -> dict[str, Any]

editor.convert_animation_export_file(source_path: str | Path, *, provider: str, folder: str | Path='Assets/Animation/Converted') -> dict[str, Any]

editor.convert_live_unity_animation(controller_asset_path: str, *, port: int | None=None, folder: str | Path='Assets/Animation/Converted/Unity') -> dict[str, Any]

editor.convert_live_unreal_animation(asset_paths: Sequence[str], *, folder: str | Path='Assets/Animation/Converted/Unreal') -> dict[str, Any]

editor.convert_unity_animation(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Animation/Converted/Unity') -> dict[str, Any]

editor.convert_unity_audio(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Audio/Converted/Unity') -> dict[str, Any]

editor.convert_unity_effects(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Effects/Converted/Unity') -> dict[str, Any]

editor.convert_unity_scriptable_objects(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Data/Converted/Unity') -> dict[str, Any]

editor.convert_unreal_animation(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Animation/Converted/Unreal') -> dict[str, Any]

editor.convert_unreal_audio(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Audio/Converted/Unreal') -> dict[str, Any]

editor.convert_unreal_data_assets(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Data/Converted/Unreal') -> dict[str, Any]

editor.convert_unreal_effects(exported_data: Mapping[str, Any], *, folder: str | Path='Assets/Effects/Converted/Unreal') -> dict[str, Any]

editor.cook(asset_ids: Iterable[str], *, platform: str='desktop', quality: str='high') -> AssetCookReceipt

editor.cook_animation_asset(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_audio_asset(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_behavior_graph(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_character_asset(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_cloth(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_effect_system(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_gameplay_foundation_asset(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_geometry_optimization(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_groom(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_image_project(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_level_sequence(asset_id: str, *, platform: str='windows', quality: str='high')

editor.cook_locomotion_controller(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_material(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_physics(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_prefab(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_procedural_graph(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_procedural_tasks(asset_id: str, *, initial_attributes: Mapping[str, Any] | None=None, workers: int=1) -> dict[str, Any]

editor.cook_rig_asset(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.cook_ui_document(asset_id: str, *, platform: str='desktop', quality: str='high') -> DerivedArtifact

editor.create_animation_clip(name: str, *, skeleton_id: str='', duration_seconds: float=1.0, sample_rate: float=30.0, loop: bool=True, folder: str | Path='Assets/Animation/Clips')

editor.create_animation_controller(name: str, *, skeleton_id: str='', properties: Mapping[str, Any] | None=None, folder: str | Path='Assets/Animation/Controllers')

editor.create_animation_mask(name: str, *, skeleton_id: str='', weights: Mapping[str, float] | None=None, folder: str | Path='Assets/Animation/Masks')

editor.create_asset(type_id: str, name: str, *, folder: str | Path='Assets', properties: Mapping[str, Any] | None=None)

editor.create_audio_attenuation(name: str, *, properties: Mapping[str, Any] | None=None, folder: str | Path='Assets/Audio/Attenuation')

editor.create_audio_mixer(name: str, *, properties: Mapping[str, Any] | None=None, folder: str | Path='Assets/Audio/Mixers')

editor.create_audio_reverb(name: str, *, preset: str='room', properties: Mapping[str, Any] | None=None, folder: str | Path='Assets/Audio/Reverb')

editor.create_behavior(name: str, *, program: Mapping[str, Any] | None=None, folder: str | Path='Assets/Gameplay/Behaviors')

editor.create_blend_space(name: str, *, skeleton_id: str='', dimensions: int=2, axes: Sequence[Mapping[str, Any]]=(), samples: Sequence[Mapping[str, Any]]=(), folder: str | Path='Assets/Animation/BlendSpaces')

editor.create_character_definition(name: str, *, properties: Mapping[str, Any] | None=None, folder: str | Path='Assets/Gameplay/Characters')

editor.create_cloth(name: str, *, source_mesh_id: str, skin_binding_id: str, fabric_material_id: str='', vertex_count: int | None=None, fixed_vertices: Iterable[int]=(), transition_vertices: Mapping[int, float] | None=None, folder: str | Path='Assets/Cloth')

editor.create_component_archetype(name: str, *, components: Sequence[Mapping[str, Any]]=(), parent_archetype_id: str='', folder: str | Path='Assets/Gameplay/Components')

editor.create_control_rig(name: str, *, skeleton_id: str, graph: Mapping[str, Any] | None=None, folder: str | Path='Assets/Animation/Rigs')

editor.create_data_schema(name: str, *, fields: Sequence[Mapping[str, Any]]=(), parent_schema_id: str='', folder: str | Path='Assets/Data/Schemas')

editor.create_data_table(name: str, *, row_schema_id: str='', rows: Sequence[Mapping[str, Any]]=(), key_field: str='id', folder: str | Path='Assets/Data/Tables')

editor.create_effect_system(name: str, *, preset: str='sparks', quality: str='high', seed: int=1, folder: str | Path='Assets/Effects')

editor.create_enum(name: str, *, entries: Sequence[Mapping[str, Any] | str]=(), flags: bool=False, folder: str | Path='Assets/Data/Enums')

editor.create_fabric_material(name: str, *, preset: str='cotton', folder: str | Path='Assets/Cloth')

editor.create_game_project_from_template(*, template_id: str='playable_sandbox', variant_id: str='', visual_style: str='', quality_profile: str='', project_name: str='StarterGame', platform: str='windows', root_folder: str | Path='Assets') -> dict[str, Any]

editor.create_gameplay_class(name: str, *, class_kind: str='actor', parent_class_id: str='', components: Sequence[Mapping[str, Any]]=(), variables: Sequence[Mapping[str, Any]]=(), folder: str | Path='Assets/Gameplay/Classes')

editor.create_gameplay_graph(name: str, *, program: Mapping[str, Any] | None=None, folder: str | Path='Assets/Gameplay/Graphs')

editor.create_geometry_optimization_profile(name: str, *, preset: str='character_balanced', source_asset_ids: Iterable[str]=(), folder: str | Path='Assets/Geometry')

editor.create_groom(name: str, *, groups: Iterable[Mapping[str, Any]], material_ids: Iterable[str]=(), source_path: str='', physics_asset_id: str='', lod_count: int=5, folder: str | Path='Assets/Grooms')

editor.create_groom_binding(name: str, *, groom_id: str, target_skeletal_mesh_id: str, source_skeletal_mesh_id: str='', binding_mode: str='skinning', folder: str | Path='Assets/Grooms/Bindings')

editor.create_hair_material(name: str, *, preset: str='brown_hair', overrides: Mapping[str, Any] | None=None, folder: str | Path='Assets/Grooms/Materials')

editor.create_ik_retargeter(name: str, *, source_ik_rig_id: str, target_ik_rig_id: str, folder: str | Path='Assets/Animation/Retargeting')

editor.create_ik_rig(name: str, *, skeleton_id: str, bones: Iterable[Mapping[str, Any] | str]=(), retarget_root: str='', folder: str | Path='Assets/Animation/Rigs')

editor.create_image_project(name: str, *, width: int=1024, height: int=1024, layers: Sequence[Mapping[str, Any]]=(), folder: str | Path='Assets/Images')

editor.create_level_sequence(name: str, *, folder: str | Path='Assets/Cinematics', duration_frames: int=300, fps: int=30)

editor.create_locomotion_controller(name: str, *, preset: str='third_person', movement_mode: str='', folder: str | Path='Assets/Animation/Locomotion')

editor.create_material(name: str, *, preset: str='default_lit', domain: str='', shading_model: str='', blend_mode: str='', folder: str | Path='Assets/Materials')

editor.create_material_instance(name: str, parent_material_id: str, *, overrides: Mapping[str, Any] | None=None, static_switch_overrides: Mapping[str, bool] | None=None, folder: str | Path='Assets/Materials/Instances')

editor.create_ocean_surface(preset: str='open_ocean', *, seed: int=1, wave_count: int=12, controls: Mapping[str, float] | None=None) -> OceanSurface

editor.create_physics_asset(name: str, *, skeleton_id: str, skeletal_mesh_id: str='', preset: str='balanced', folder: str | Path='Assets/Physics')

editor.create_physics_constraint(name: str, *, first_body: str, second_body: str, preset: str='weld', settings: Mapping[str, Any] | None=None, folder: str | Path='Assets/Physics')

editor.create_prefab(name: str, entities: Sequence[Mapping[str, Any]], *, folder: str | Path='Assets/World', exposed_properties: Mapping[str, Any] | None=None)

editor.create_prefab_variant(name: str, base_prefab_id: str, *, overrides: Mapping[str, Any] | None=None, added_entities: Sequence[Mapping[str, Any]]=(), removed_entity_ids: Sequence[str]=(), folder: str | Path='Assets/World/Variants')

editor.create_procedural_graph(name: str, *, graph: ProceduralGraph | None=None, folder: str | Path='Assets/Procedural')

editor.create_project_settings(name: str='ProjectSettings', *, properties: Mapping[str, Any] | None=None, folder: str | Path='Settings')

editor.create_runtime_physics_joint(runtime_world: MutableMapping[str, Any], joint_id: str, first: str, second: str, *, joint_type: str='fixed', preset: str='', settings: Mapping[str, Any] | None=None) -> dict[str, Any]

editor.create_runtime_soft_body(vertices: Iterable[Sequence[float]], faces: Iterable[Sequence[int]], *, material: str='jello', pinned_vertices: Iterable[int]=(), volume_compliance: float=2e-07) -> Any

editor.create_shader_graph(name: str, *, stage: str='surface', language: str='portable', graph: Mapping[str, Any] | None=None, include_asset_ids: Sequence[str]=(), folder: str | Path='Assets/Shaders')

editor.create_skeletal_mesh_asset(name: str, *, skeleton_id: str, skin_binding_id: str='', bones: Iterable[Mapping[str, Any] | str]=(), preserve_bones: Iterable[str]=(), lod_count: int=4, folder: str | Path='Assets/Characters')

editor.create_skeleton(name: str, *, bones: Iterable[Mapping[str, Any]], sockets: Iterable[Mapping[str, Any]]=(), retarget_pose: Mapping[str, Any] | None=None, preserve_bones: Iterable[str]=(), folder: str | Path='Assets/Characters/Rig')

editor.create_skin_binding(name: str, *, mesh_id: str, skeleton_id: str, dcc_payload: Mapping[str, Any], folder: str | Path='Assets/Characters')

editor.create_sound_cue(name: str, *, properties: Mapping[str, Any] | None=None, folder: str | Path='Assets/Audio/Cues')

editor.create_starter_character(name: str='TC_Starter_Mannequin', *, visual_style: str='stylized_pbr', dimensionality: str='3d', folder: str | Path='Assets/Characters/Starter') -> dict[str, Any]

editor.create_struct(name: str, *, fields: Sequence[Mapping[str, Any]]=(), parent_schema_id: str='', folder: str | Path='Assets/Data/Structs')

editor.create_typed_data_asset(name: str, *, schema_asset_id: str='', values: Mapping[str, Any] | None=None, folder: str | Path='Assets/Data')

editor.create_ui_document(name: str, *, folder: str | Path='Assets/UI', values: Mapping[str, Any] | None=None)

editor.create_world_asset(type_id: str, name: str, *, folder: str | Path='Assets/World', properties: Mapping[str, Any] | None=None)

editor.debug_gameplay_class(asset_id: str, context: Mapping[str, Any] | None=None) -> dict[str, Any]

editor.delete_content_browser_collection(name: str) -> bool

editor.delete_level_actors(level_asset_id: str, actor_ids: Iterable[str]) -> dict[str, Any]

editor.duplicate_level_actors(level_asset_id: str, actor_ids: Iterable[str]) -> dict[str, Any]

editor.edit_runtime_physics_joints(runtime_world: MutableMapping[str, Any], joint_ids: Iterable[str], changes: Mapping[str, Any]) -> int

editor.effect_module_library() -> dict[str, dict[str, Any]]

editor.effect_presets() -> tuple[str, ...]

editor.effect_properties(asset_id: str) -> dict[str, Any]

editor.end_gameplay_class_debug_session(session_id: str, *, keep_changes: bool=False) -> dict[str, Any]

editor.estimate_effect_cost(asset_id: str, *, quality: str='high') -> dict[str, Any]

editor.evaluate_animation_controller(asset_id: str, *, parameter_values: Mapping[str, Any] | None=None, layer_id: str='', current_state: str='', normalized_time: float=0.0) -> dict[str, Any]

editor.evaluate_blend_space(asset_id: str, x: float, y: float=0.0) -> dict[str, float]

editor.evaluate_level_sequence(asset_id: str, frame: int) -> dict[str, Any]

editor.execute_behavior_graph(asset_id: str, context: Mapping[str, Any] | None=None) -> dict[str, Any]

editor.execute_bulk_asset_operation(operation: str, asset_ids: Iterable[str], *, options: Mapping[str, Any] | None=None) -> dict[str, Any]

editor.export_animation_interchange(asset_ids: Iterable[str]) -> dict[str, Any]

editor.export_assets(asset_ids: Iterable[str], destination: str | Path, *, target: str='generic', include_dependencies: bool=True, require_ready: bool=False) -> dict[str, Any]

editor.flatten_image_project(asset_id: str) -> bytes

editor.gameplay_class_debug_command(session_id: str, command: str, **options: Any) -> dict[str, Any]

editor.generate_character_lods(asset_id: str, bones: Iterable[Mapping[str, Any] | str], *, count: int=4, preserve_bones: Iterable[str]=()) -> dict[str, Any]

editor.generate_groom_lods(asset_id: str, *, count: int=5, include_cards: bool=True, include_mesh: bool=True) -> list[dict[str, Any]]

editor.generate_mesh_lod_geometry(asset_id: str, source_path: str | Path, *, custom_lod_sources: Mapping[int, str | Path] | None=None, output_folder: str | Path='Derived/CharacterLODs', include_animation: bool=False, timeout: float=300.0) -> dict[str, Any]

editor.generate_ocean_patch(ocean: OceanSurface, *, center: Sequence[float]=(0.0, 0.0), size: float=20.0, rows: int=32, columns: int=32) -> dict[str, Any]

editor.generate_runtime_ragdoll(rig_graph: Any, runtime_world: dict[str, Any], *, root_joint: str='', density: float=985.0, include_leaf_joints: bool=False) -> dict[str, Any]

editor.get_level_sequence(asset_id: str) -> dict[str, Any]

editor.get_procedural_graph(asset_id: str) -> dict[str, Any]

editor.get_world_asset(asset_id: str) -> dict[str, Any]

editor.import_animation_interchange(payload: Mapping[str, Any], *, folder: str | Path='Assets/Animation/Converted') -> dict[str, Any]

editor.import_asset(source_path: str | Path, *, folder: str | Path='Assets', type_id: str='', importer_settings: Mapping[str, Any] | None=None)

editor.import_procedural_native_document(document: Mapping[str, Any], *, name: str='ImportedProceduralGraph', folder: str | Path='Assets/Procedural')

editor.input_map_audit(asset_id: str) -> dict[str, Any]

editor.instantiate_prefab(asset_id: str, *, overrides: Mapping[str, Any] | None=None, expand_nested: bool=False) -> dict[str, Any]

editor.isolate_level_actors(level_asset_id: str, actor_ids: Iterable[str]) -> dict[str, Any]

editor.level_actors(level_asset_id: str) -> tuple[dict[str, Any], ...]

editor.level_sequence_render_jobs(asset_id: str) -> tuple[dict[str, Any], ...]

editor.list_gameplay_class_debug_sessions() -> tuple[dict[str, Any], ...]

editor.material_graph_statistics(asset_id: str, *, platform: str='desktop') -> dict[str, Any]

editor.material_presets() -> tuple[str, ...]

editor.move_level_actors_to_folder(level_asset_id: str, actor_ids: Iterable[str], folder: str) -> dict[str, Any]

editor.open_world_streaming_runtime(world_partition_asset_id: str) -> WorldStreamingRuntime

editor.paint_foliage(asset_id: str, *, center: tuple[float, float], radius: float, density: float=1.0, erase: bool=False, seed: int=0) -> dict[str, Any]

editor.paint_terrain_layer(asset_id: str, layer: str, *, center: tuple[float, float], radius: float, strength: float) -> dict[str, Any]

editor.parent_level_actors(level_asset_id: str, actor_ids: Iterable[str], parent_actor_id: str='') -> dict[str, Any]

editor.perforce_asset_action(asset_ids: Iterable[str], action: str, *, changelist: str='', confirmed: bool=False) -> dict[str, Any]

editor.perforce_changelists(*, status: str='pending', limit: int=50) -> tuple[dict[str, Any], ...]

editor.plan_asset_reference_replacement(asset_id: str, replacement_asset_id: str, *, owner_asset_ids: Iterable[str]=()) -> dict[str, Any]

editor.plan_bulk_asset_operation(operation: str, asset_ids: Iterable[str], *, options: Mapping[str, Any] | None=None) -> dict[str, Any]

editor.plan_geometry_optimization(asset_id: str) -> dict[str, Any]

editor.plan_navigation_rebuild(asset_id: str, previous_values: Mapping[str, Any]) -> dict[str, Any]

editor.preview_ui_document(asset_id: str, *, viewport: tuple[int, int] | None=None) -> dict[str, Any]

editor.preview_world_asset(asset_id: str, *, maximum_resolution: int=257) -> dict[str, Any]

editor.procedural_diagnostics(asset_id: str) -> dict[str, Any]

editor.procedural_execution_plan(asset_id: str, *, backend: str='auto') -> dict[str, Any]

editor.procedural_native_document(asset_id: str, target: str) -> dict[str, Any]

editor.procedural_operation_catalog() -> tuple[str, ...]

editor.process_asset_import_queue() -> tuple[dict[str, Any], ...]

editor.project_groom_binding(asset_id: str, roots: Sequence[Sequence[float]], vertices: Sequence[Sequence[float]], triangles: Sequence[Sequence[int]]) -> list[dict[str, Any]]

editor.properties(asset_id: str) -> dict[str, Any]

editor.qualify_capability_evidence(*, timeout_seconds: float=300.0) -> dict[str, Any]

editor.qualify_content_browser(*, sample_count: int=50000, query_budget_ms: float=750.0, inventory_budget_ms: float=2000.0) -> dict[str, Any]

editor.qualify_content_production(*, maximum_total_seconds: float=30.0) -> dict[str, Any]

editor.qualify_dcc_release(host: str, *, workspace: str | Path | None=None, session_port: int | None=None, confirm_mutating: bool=False, install_recovery_verified: bool=False, progress_callback: Any | None=None, cancellation_event: Any | None=None) -> dict[str, Any]

editor.qualify_playable_project(player_executable: str | Path, *, frames: int=120, budgets_ms: Mapping[str, float] | None=None) -> dict[str, Any]

editor.qualify_realtime_fx(*, presets: Sequence[str] | None=None, frames: int=120, frame_budget_ms: float=16.667, maximum_particles: int=2048, maximum_preset_seconds: float=8.0) -> dict[str, Any]

editor.qualify_world_production(*, maximum_total_seconds: float=30.0) -> dict[str, Any]

editor.query_navigation_path(asset_id: str, *, start: tuple[float, float], goal: tuple[float, float], agent_name: str='') -> dict[str, Any]

editor.queue_asset_imports(source_paths: Iterable[str | Path], *, folder: str='Assets', type_id: str='') -> tuple[dict[str, Any], ...]

editor.reimport_asset(asset_id: str)

editor.remove_runtime_physics_joint(runtime_world: MutableMapping[str, Any], joint_id: str) -> bool

editor.remove_sequence_section(asset_id: str, track_id: str, section_id: str) -> bool

editor.remove_sequence_track(asset_id: str, track_id: str) -> bool

editor.reorder_level_actor_component(level_asset_id: str, actor_id: str, component_id: str, new_index: int) -> dict[str, Any]

editor.repair_content_browser_references(*, prune_stale_redirectors: bool=True) -> dict[str, Any]

editor.replace_asset_references(asset_id: str, replacement_asset_id: str, *, owner_asset_ids: Iterable[str]=()) -> dict[str, Any]

editor.reset_procedural_simulation(asset_id: str, *, session_id: str='preview') -> bool

editor.resolve_data_schema(asset_id: str) -> dict[str, Any]

editor.resolve_gameplay_class(asset_id: str) -> dict[str, Any]

editor.resolve_material(asset_id: str) -> dict[str, Any]

editor.resolve_prefab(asset_id: str, *, expand_nested: bool=True) -> dict[str, Any]

editor.revert_material_instance_overrides(asset_id: str, names: Sequence[str]=()) -> dict[str, Any]

editor.revert_prefab_overrides(asset_id: str, overrides: Mapping[str, Any], *, paths: Sequence[str]=()) -> dict[str, Any]

editor.sample_ocean_surface(ocean: OceanSurface, x: float, z: float, *, time_seconds: float | None=None) -> dict[str, Any]

editor.save_content_browser_collection(name: str, *, asset_ids: Iterable[str]=(), query: str='', kind: str='static') -> dict[str, Any]

editor.save_level_camera_bookmark(level_asset_id: str, slot: int, camera: Mapping[str, Any]) -> dict[str, Any]

editor.sculpt_terrain(asset_id: str, *, center: tuple[float, float], radius: float, strength: float, mode: str='raise', target_height: float | None=None) -> dict[str, Any]

editor.sequence_binding(name: str, *, object_id: str='', binding_type: str='possessable', parent_binding_id: str='', component_path: str='', bone_name: str='', socket_name: str='', skeleton_asset_id: str='') -> dict[str, Any]

editor.sequence_folder(name: str, *, parent_id: str='') -> dict[str, Any]

editor.sequence_from_unity(payload: Mapping[str, Any]) -> dict[str, Any]

editor.sequence_from_unreal(payload: Mapping[str, Any]) -> dict[str, Any]

editor.sequence_key(section: dict[str, Any], channel_name: str, frame: float, value: Any, *, interpolation: str='linear') -> dict[str, Any]

editor.sequence_level_blend(name: str, level_asset_id: str, start_frame: int, end_frame: int, *, ease_in: int=30, ease_out: int=30, blend_mode: str='crossfade') -> dict[str, Any]

editor.sequence_section(name: str, start_frame: int, end_frame: int, *, asset_id: str='', row: int=0) -> dict[str, Any]

editor.sequence_to_unity(payload: Mapping[str, Any]) -> dict[str, Any]

editor.sequence_to_unreal(payload: Mapping[str, Any]) -> dict[str, Any]

editor.sequence_track(track_type: str, name: str='', *, binding_id: str='', parent_id: str='') -> dict[str, Any]

editor.set_animation_properties(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.set_audio_clip_settings(asset_id: str, values: Mapping[str, Any]) -> dict[str, Any]

editor.set_cloth_map(asset_id: str, map_name: str, values: Sequence[float]) -> dict[str, Any]

editor.set_effect_properties(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.set_level_actor_lock(level_asset_id: str, actor_ids: Iterable[str], locked: bool) -> dict[str, Any]

editor.set_level_actor_render_mesh(level_asset_id: str, actor_name: str, mesh_asset_id: str) -> dict[str, Any]

editor.set_level_actor_visibility(level_asset_id: str, actor_ids: Iterable[str], visible: bool) -> dict[str, Any]

editor.set_material_instance_overrides(asset_id: str, overrides: Mapping[str, Any], *, replace: bool=False, static_switches: Mapping[str, bool] | None=None) -> dict[str, Any]

editor.set_procedural_graph(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.set_properties(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.set_texture_import_settings(asset_id: str, values: Mapping[str, Any]) -> dict[str, Any]

editor.shader_backend_capabilities() -> dict[str, Any]

editor.show_all_level_actors(level_asset_id: str) -> dict[str, Any]

editor.step_procedural_simulation(asset_id: str, *, session_id: str='preview', delta_time: float | None=None) -> dict[str, Any]

editor.texture_import_settings(asset_id: str) -> dict[str, Any]

editor.transform_level_actors(level_asset_id: str, actor_ids: Iterable[str], *, translation: Iterable[float]=(0.0, 0.0, 0.0), rotation: Iterable[float]=(0.0, 0.0, 0.0), scale_multiplier: Iterable[float]=(1.0, 1.0, 1.0)) -> dict[str, Any]

editor.transform_sequence_keys(asset_id: str, track_id: str, section_id: str, channel_name: str, **transform: float) -> dict[str, Any]

editor.update_character_asset(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.update_input_map(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.update_level_sequence(asset_id: str, values: Mapping[str, Any])

editor.update_ui_document(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.update_world_asset(asset_id: str, values: Mapping[str, Any], *, replace: bool=False) -> dict[str, Any]

editor.validate_animation_asset(asset_id: str) -> list[dict[str, Any]]

editor.validate_audio_asset(asset_id: str) -> list[dict[str, Any]]

editor.validate_behavior_graph(asset_id: str) -> list[dict[str, Any]]

editor.validate_character_asset(asset_id: str) -> list[dict[str, Any]]

editor.validate_cloth(asset_id: str, *, vertex_count: int | None=None) -> list[dict[str, Any]]

editor.validate_effect_system(asset_id: str, *, platform: str='desktop', quality: str='high') -> list[dict[str, Any]]

editor.validate_gameplay_class(asset_id: str) -> list[dict[str, Any]]

editor.validate_gameplay_foundation_asset(asset_id: str) -> list[dict[str, Any]]

editor.validate_geometry_optimization(asset_id: str) -> list[dict[str, Any]]

editor.validate_groom(asset_id: str) -> list[dict[str, Any]]

editor.validate_image_project(asset_id: str) -> list[dict[str, Any]]

editor.validate_level_sequence(asset_id: str)

editor.validate_locomotion_controller(asset_id: str) -> list[dict[str, Any]]

editor.validate_material(asset_id: str, *, platform: str='desktop') -> list[dict[str, Any]]

editor.validate_physics(asset_id: str) -> list[dict[str, Any]]

editor.validate_playable_project(ruleset_asset_id: str, build_profile_asset_id: str='') -> dict[str, Any]

editor.validate_prefab(asset_id: str) -> list[dict[str, Any]]

editor.validate_procedural_graph(asset_id: str) -> list[dict[str, Any]]

editor.validate_rig_asset(asset_id: str) -> list[dict[str, Any]]

editor.validate_shader_graph(asset_id: str, *, platform: str='desktop') -> list[dict[str, Any]]

editor.validate_ui_document(asset_id: str) -> dict[str, Any]

editor.validate_world_asset(asset_id: str) -> list[dict[str, Any]]

editor.world_asset_visualization(asset_id: str) -> dict[str, Any]