# Built-in Catalog Overview

## Summary

Flow Core ships with built-in Instructions, Conditions, generated member entries, and enum resolvers. Use this page to understand what those catalogs are for and how to decide whether to use an existing entry, generate a new one, or write a custom extension.

Catalog size is a convenience signal, not a design target. A good graph still starts from the reader's task: what should happen, what data should be checked, and where the result should be observable.

## Use When

* You are looking for an existing instruction or condition.
* You are deciding whether a missing operation should be generated or written manually.
* You are explaining the difference between node behavior and instruction/condition behavior.
* You are reviewing generated catalog coverage after a plugin or Unity API change.

## Catalog Types

| Catalog type             | What it represents                                                                   | Use it for                                                                                            |
| ------------------------ | ------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Instructions             | Actions that perform work when an Action node or hook runs them.                     | Set values, call methods, spawn objects, play effects, change scene state, or log/debug results.      |
| Conditions               | Checks that return pass/fail inside Guards, BTCondition nodes, and condition groups. | Gate execution, branch behavior, validate state, or protect an operation.                             |
| Member-generated entries | Generated wrappers around supported members from selected assemblies or APIs.        | Reusing common Unity, System, TMPro, or Flow Core-facing operations without writing one-off wrappers. |
| Enum resolvers           | Generated enum value helpers used by fields and UI.                                  | Present stable enum choices in generated entries and editor drawers.                                  |

## How to Choose

| Need                                                                | Choose                                       |
| ------------------------------------------------------------------- | -------------------------------------------- |
| "Do this thing now."                                                | Instruction                                  |
| "Only continue if this is true."                                    | Condition                                    |
| "Call a common property, method, or API that already exists."       | Member-generated instruction or condition    |
| "Expose a project-specific gameplay verb with a good display name." | Custom instruction or condition              |
| "Reuse the same authored check in many places."                     | Custom condition, possibly with Auto UI tags |
| "Coordinate flow between nodes."                                    | A node, not an instruction                   |

## Counts Snapshot

These counts describe the current public catalog snapshot. They can change after generator runs, package updates, or extension work.

| Category                      | Count |
| ----------------------------- | ----: |
| Core built-in instructions    |  1508 |
| Core built-in conditions      |    95 |
| Member-generated instructions |  5080 |
| Member-generated conditions   |   739 |
| Enum resolvers                |    72 |
| Total instructions            |  6588 |
| Total conditions              |   834 |

## Member-generated Coverage

| Area        | Instructions | Conditions | Typical use                                                                              |
| ----------- | -----------: | ---------: | ---------------------------------------------------------------------------------------- |
| UnityEngine |         3609 |        528 | GameObject, Component, Transform, math, rendering, physics, and scene-facing operations. |
| System      |          647 |        117 | Basic .NET types, collections, strings, numeric helpers, and utility operations.         |
| TMPro       |          808 |         94 | TextMeshPro text, dropdown, input, and UI-related operations.                            |
| TwoCatsCode |           16 |          0 | Flow Core-facing helper operations that are safe to expose publicly.                     |

## Finding the Right Entry

1. Start from the node role. If you need a chain step, use an Action node; if you need a guard, open a Condition field.
2. Search by the gameplay verb first, such as `Set`, `Play`, `Move`, `Log`, `Compare`, or `Has`.
3. Search by the target type second, such as `GameObject`, `Transform`, `Text`, `Blackboard`, or `String`.
4. Prefer a clear, narrow entry over a generic one that needs extra explanation.
5. If the entry exists but is hard to read in a graph, consider a small custom wrapper with a better display name.

## Generate or Write Custom

| Situation                                                              | Recommended path                                                                   |
| ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| A common API member is missing from the generated catalog.             | Review the codegen generator setup and regenerate selected outputs.                |
| A generated entry exists but exposes too many low-level parameters.    | Write a custom instruction or condition for the gameplay-facing task.              |
| The operation depends on project-specific services or scene ownership. | Write a custom extension and document the supported assumptions.                   |
| The operation is a one-off inside one graph.                           | Use existing built-ins before adding a new extension type.                         |
| The operation needs persistent data or save/load behavior.             | Use the persistence extension path instead of hiding save logic in an instruction. |

## Constraints

* Catalog counts are snapshots, not compatibility guarantees.
* Generated entries expose supported wrappers, not every public C# member as a stable user-facing API.
* Instructions should perform work. Conditions should answer a question. Nodes should own flow shape.
* Avoid using generated entries to depend on unsupported internals.

## Related

* [Instruction Reference](/flow-core-docs/documentation/reference/instructions.md)
* [Condition Reference](/flow-core-docs/documentation/reference/conditions.md)
* [Logic And / Logic Or](https://github.com/HaikunHuang/FlowCore/blob/main/reference/conditions/condition-logic-groups.md)
* [Codegen Generators](/flow-core-docs/documentation/api-extension-guide/codegen-generators.md)
* [Codegen Pipeline](/flow-core-docs/documentation/api-extension-guide/codegen-pipeline.md)
* [Generated Items](/flow-core-docs/documentation/api-extension-guide/generated-items.md)
* [Flow Node Kinds](/flow-core-docs/documentation/reference/flow-node-kinds.md)
* [Extension Points](/flow-core-docs/documentation/api-extension-guide/extension-points.md)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://flow-core.gitbook.io/flow-core-docs/documentation/reference/built-in-catalog-overview.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.