sel/wgu
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases 1 Packages Wiki Activity Actions

added proper capitalization and formalization, cleared up everything

selene 2026-01-16 15:47:52 +01:00
parent d130863a46
commit ec676007b5
Signed by: sel
SSH key fingerprint: SHA256:33R/4Rx5Lu4o81LyJyXdMrmP5CJ6j7j1Soo0Dn7mKc0
8 changed files with 249 additions and 260 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Home.md

@ -1,3 +1,3 @@
# welcome to the wiki
zomg hiii >w< welcome to the wgu wiki!!
for an overview of what wgu is, see the [readme](https://codeberg.org/selstacker/wgu)
You can use the sidebar to read different pages. For an overview of what wgu is, see the [README](https://codeberg.org/selstacker/wgu).

6
_Sidebar.md

@ -1,3 +1,3 @@
- [objects](object.md)
- [variants of `ModuleItem`](modularity.md)
- [built-in modules](modules.md)
- [Modular Object Format Specification](format.md)
- [Addressing of module items](modularity.md)
- [Built-in modules](modules.md)

163
format.md Normal file

@ -0,0 +1,163 @@
# Modular Object Format Specification
## Introduction
The **modular object format** is a framework-esque *informal* set of schemas & an *informal* specification, for analyzing and performing basic operations on structured computer data, referred to as **object instances**.
The basic data structure of object instances is defined in `wgu::types::ObjectInstance` / by the **base template**, available below. Object instances are key-value stores, where keys are generally referred to as 'properties'. Property names may contain [alphanumerics](https://en.wikipedia.org/wiki/Alphanumericals), `-` (dashes), and `_` (underscores). `.` (dots) represent a level of nesting.
When transmitted over a network or stored on disk, object instances are generally serialized into [JSON](https://www.json.org/json-en.html) [object literals](https://benalman.com/news/2010/03/theres-no-such-thing-as-a-json/).
Data within object instances is divided into three categories, `input`, `local`, and `remote`, each corresponding to the origin of data contained within. The inner structure of these categories is determined by a module-defined template, which is specified by the `object_type` property. Metadata (`version`, `object_type`, timestamps, hashes, etc.) is stored alongside these categories.
For referencing object instances, the properties `version` and `input_sha256` are used, separated by a `.` (dot) symbol.
> **Example:** `0.abcd...1234`
To refer to a property within an object, add a `:` (colon) symbol, followed by the property name.
> **Example:** `0.abcd...1234:input.value`
if the property you're referring to is an array, the position of the target value must also be specified within `[]` (square brackets):
> **Example:** `0.abcd...1234:remote.some.thing[2]`
## Base template
The following properties serve as the starting point for the structure of all object instances.
### Categories
| property | transforms | subobjects | conditions | array | value |
| -------- | ---------- | ---------- | ---------- | ----- | ------------------------------------------------------------------------------------------------------- |
| `input` | none | none | none | false | Holds essential data needed for defining the object instance's content, and populating other properties |
| `local` | none | none | none | false | Holds *locally calculated* data |
| `remote` | none | none | none | false | Holds *remotely obtained* data |
| `logs` | none | none | none | true | Holds logs produced in relation to the object instance |
### General
| property | transforms | subobjects | conditions | array | value |
| ------------- | ------------------- | ---------- | ---------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `object_type` | `meta/text:value` | none | none | false | Specifies the object's expected content. Content before the `/` (slash) is the module name, after that `.` (dots) are used to separate layers of nesting |
| `version` | `meta/number:value` | none | none | false | Used for differentiating between multiple object instances with the same `input_sha256`. starts at `0` (zero) for each hash. |
### Timestamps
> **this section needs more expansion!** you can contribute by documenting how this feature or module operates in the latest available version (also check for pull requests that would change that)
| property | transforms | subobjects | conditions | array | value |
| --------- | ------------------------ | ---------- | ---------- | ----- | --------------------------------------------------- |
| `created` | `meta/timestamp:unix-ms` | none | none | false | Timestamp of the object instance's creation |
| `edited` | `meta/timestamp:unix-ms` | none | none | false | Timestamp of the object instance's last manual edit |
| `hashed` | `meta/timestamp:unix-ms` | none | none | false | Timestamp of `input_sha256` being calculated |
### Hashing
| property | transforms | subobjects | conditions | array | value |
| -------------- | ----------------- | ---------- | ---------- | ----- | -------------------------------------------------------------------------------------------------- |
| `input_sha256` | `meta/text:value` | none | none | false | Used for naming, querying, and referencing object instances (together with the `version` property) |
| `full_sha256` | `meta/text:value` | none | none | false | Using for validating object instances (together with properties under `timestamps`) |
`input_sha256` is calculated as the SHA-256 checksum of the property `object_type` and properties under `input`, including the start and end braces, separated by `+` (plus) symbols.
> **Example:** `meta/dummy+{"value":"you are now breathing manually"}` -> `5aea ... b0ca`
`full_sha256` is calculated as the SHA-256 checksum of the property `object_type`, the timestamp `hashed`, and the categories `input`, `local`, and `remote`, including the start and end braces, separated by `+` (plus) symbols.
> **Example:** `meta/dummy+1735689600000+{"value":"you are now breathing manually"}+{}+{}` -> `7f17 ... cbdc`
### Logging
| property | transforms | subobjects | conditions | array | value |
| ---------------- | ------------------------ | ---------- | ---------------------------------------------- | ----- | -------------------------------------------- |
| `logs.level` | `meta/text:value` | none | `logs.level`: `error`, `warn`, `info`, `debug` | false | Categorizing the log entry by severity level |
| `logs.variant` | `meta/text:value` | none | none | false | Categorizing the log entry generally |
| `logs.timestamp` | `meta/timestamp:unix-ms` | none | none | false | Timestamp of the log entry |
| `logs.message` | `meta/text:value` | none | none | false | Human-readable message |
## Transformations
A transformation (most commonly referred to as a 'transform') is an operation involving taking any property of an object instance, and placing its value into that of a property under `input` of a new object instance. These are some examples of common transforms:
- existing `meta/text:local.length` -> new `meta/number:value`
- existing `net/url:local.domain` -> new `net/domain:value`
- existing `social/twitter.post:remote.posted` -> new `meta/timestamp:unix-ms`
<small>(all of these examples are only demonstrational)</small>
Outgoing transforms of any property are defined in the [template of the source object](#transforms-1) under the source property as the destination object & property, which must always be under `input`.
If an entire object template is used as an outgoing transform, a level of nesting is created within the source property, where the properties under `input` of the destination object template are placed.
## Subobjects
Object instances may have parent-child relationships with other object instances as defined in the parent object instance's template, provided the parent and child object instances share a property. This works similarly to SQL's primary keys, and is commonly used when a piece of data is categorized under another in the data origin. These are some examples:
- `social/twitter.post` is a subobject of `social/twitter.user`, using `remote.author`
- `web/youtube.video` is a subobject of `web/youtube.user`, using `remote.author`
- `web/gitea.repository` is a subobject of `web/gitea.user` and `web/gitea.organization`, using `remote.owner`
<small>(all of these examples are only demonstrational)</small>
Similarly to [transformations](#transformations), subobjects are defined in the [template of the parent object](#subobjects-1), as the child object & the two objects' shared property (most commonly an identifier, such as an incrementing number or UUID). This shared property must have the same [outgoing transforms](#transforms) in both the parent and child.
## Template structure
Object templates (also referred to as 'templates') are a collection of [TOML tables](https://toml.io/en/v1.1.0#table) representing & named after each property. Modules may expose templates (`wgu::modules::ModuleItem::Template`), which extend the base template for object instances of a specific `object_type`.
For referencing templates, the name of the module and the name of the template are used, separated by a `/` (slash) symbol.
> **Example:** `meta/text:input.value`
A good example is the (possibly simplest) module-exposed template of the [`meta/dummy`](meta-dummy.md) object type.
```toml
[input.value]
transforms = ["meta/text:value"]
subobjects = []
conditions = []
array = false
```
Which then looks like this in the documentation:
| property | transforms | subobjects | conditions | array | value |
| ------------- | ----------------- | ---------- | ---------- | ----- | ---------------- |
| `input.value` | `meta/text:value` | none | none | false | dummy text value |
### `transforms`
Array of object types & their properties under `input`, that this property transforms to, separated by a `:` (colon) symbol.
### `subobjects`
Array of objects & their properties under `input`, that this property matches the [outgoing transforms](#transforms-1) of, separated by a `:` (colon) symbol.
### `conditions`
Array of references to other properties within the object, which may be itself, combined with values the target property must have for this property to be valid in the object instance.
An example would look like this:
```toml
conditions = [
["input.value", "owo"],
["input.version", "fact-checked by real transgender patriots"]
]
```
If a property is referenced multiple times, all of the provided options will be valid. This is an example from `meta/connection`:
```toml
conditions = [
["input.version", "function"]
["input.version", "transform"]
["input.version", "subobject"]
["input.version", "custom"]
]
```
### `array`
If `true`, the property will act as a collection of properties (referred to as an 'array'). When used as a transform destination, arrays add the source property's value to the first (0th) position.

21
meta-connection.md

@ -1,17 +1,14 @@
# `meta/connection`
`meta/connection` is an object template of the `meta` module used for representing connections & relationships between object instances.
`meta/connection` is an object template of the `meta` module, used for representing connections & relationships between object instances.
## template
### inputs
| name | transforms | subobjects | conditions | duplicates | value |
| ---------- | ----------------- | ---------- | --------------------------------------------------------------- | ---------- | ----------------------------------------------------------------- |
| `variant` | `meta/text:value` | none | `input.variant`: `function`, `transform`, `subobject`, `custom` | false | for specifying the variant of connection for other properties |
| `from` | `meta/text:value` | none | none | true | for specifying the reference string of the **source object** |
| `to` | `meta/text:value` | none | none | true | for specifying the reference string of the **destination object** |
| `property` | `meta/text:value` | none | `input.variant`: `transform`, `subobject` | false | for specifying the affected property in transforms and subobjects |
| `value` | `meta/text:value` | none | `input.variant`: `custom` | false | for specifying the note in custom connections |
## Template
| property | transforms | subobjects | conditions | duplicates | value |
| ---------------- | ----------------- | ---------- | --------------------------------------------------------------- | ---------- | ------------------------------------------------------------ |
| `input.variant` | `meta/text:value` | none | `input.variant`: `function`, `transform`, `subobject`, `custom` | false | Specifies the variant of connection for other properties |
| `input.from` | `meta/text:value` | none | none | true | Specifies the reference string of the source object |
| `input.to` | `meta/text:value` | none | none | true | Specifies the reference string of the destination object |
| `input.property` | `meta/text:value` | none | `input.variant`: `transform`, `subobject` | false | Specifies the affected property in transforms and subobjects |
| `input.value` | `meta/text:value` | none | `input.variant`: `custom` | false | Specifies the note in custom connections |

9
meta-dummy.md Normal file

@ -0,0 +1,9 @@
# `meta/dummy`
`meta/dummy` is an object template of the `meta` module, used for examples, testing, etc.
## Template
| property | transforms | subobjects | conditions | array | value |
| ------------- | ----------------- | ---------- | ---------- | ----- | ---------------- |
| `input.value` | `meta/text:value` | none | none | false | dummy text value |

18
modularity.md

@ -1,23 +1,13 @@
# modularity
> **under construction**
>
> **this document needs more expansion!** you can contribute by documenting how this feature or module operates in the latest available version (also check for pull requests that would change that)
# Addressing of module items
## `... ModuleItem::Template`
an object template is a [toml](https://toml.io) blueprint of an `wgu::types::ObjectInstance`. it is exported from modules as a `&'static str`.
for referencing templates, the name of the module and the name of the template are used, separated by a `/` (slash) symbol: `{object_type}`
For referencing templates, the following syntax is used: `{object_type}`
## `... ModuleItem::Validator`
validators take one [object instance](object.md#instances), and output a `Result` based on whether the object instance passes validation.
for referencing validators, the following syntax is used: `{object_type}:func:validator`
For referencing validators, the following syntax is used: `{object_type}:func:validator`
## `... ModuleItem::Function`
functions take hashmaps of named object instances as inputs (and parameters), and output another hashmap of named object instances.
for referencing functions, the following syntax is used: `func:{name}`
For referencing functions, the following syntax is used: `{optional object_type}:func:{name}`

118
modules.md

@ -1,89 +1,89 @@
# built-in modules
# Built-in modules
## `meta`
this module has object templates for primitives and other basic types of data most other modules rely on.
This module has object templates for primitives and other basic types of data.
### general data types
### General data types
| object template | readable name |
| template | readable name |
| --------------------------------------- | ------------- |
| `meta/bool` | boolean |
| [`meta/bool`](meta-boolean.md) | boolean |
| [`meta/connection`](meta-connection.md) | connection |
| `meta/dummy` | dummy text |
| `meta/log` | log |
| `meta/number` | number |
| `meta/text` | text |
| `meta/tag` | tag |
| `meta/timestamp` | timestamp |
| [`meta/dummy`](meta-dummy.md) | dummy text |
| [`meta/number`](meta-number.md) | number |
| [`meta/text`](meta-text.md) | text |
| [`meta/tag`](meta-tags.md) | tag |
| [`meta/timestamp`](meta-timestamp.md) | timestamp |
### image files
### Image files
| object template | readable name |
| template | readable name |
| ---------------------- | --------------- |
| `meta/file.image.png` | png image file |
| `meta/file.image.jpg` | jpeg image file |
| `meta/file.image.gif` | gif image file |
| `meta/file.image.webp` | webp image file |
| `meta/file.image.png` | PNG image file |
| `meta/file.image.jpg` | JPEG image file |
| `meta/file.image.gif` | GIF image file |
| `meta/file.image.webp` | WebP image file |
### audio files
### Audio files
| object template | readable name |
| template | readable name |
| ---------------------- | --------------- |
| `meta/file.audio.mp3` | mp3 audio file |
| `meta/file.audio.wav` | wav audio file |
| `meta/file.audio.flac` | flac audio file |
| `meta/file.audio.ogg` | ogg video file |
| `meta/file.audio.opus` | opus video file |
| `meta/file.audio.mp3` | MP3 audio file |
| `meta/file.audio.wav` | WAV audio file |
| `meta/file.audio.flac` | FLAC audio file |
| `meta/file.audio.ogg` | OGG video file |
| `meta/file.audio.opus` | OPUS video file |
### video files
### Video files
| object template | readable name |
| template | readable name |
| ---------------------- | --------------- |
| `meta/file.media.mp4` | mp4 media file |
| `meta/file.media.webm` | webm media file |
| `meta/file.media.mkv` | mkv media file |
| `meta/file.media.avi` | avi media file |
| `meta/file.media.ts` | ts media file |
| `meta/file.media.mp4` | MP4 media file |
| `meta/file.media.webm` | WebM media file |
| `meta/file.media.mkv` | MKV media file |
| `meta/file.media.avi` | AVI media file |
| `meta/file.media.ts` | TS media file |
### document files
### Document files
| object template | readable name |
| template | readable name |
| ------------------------- | --------------------------------- |
| `meta/file.document.docx` | microsoft word document |
| `meta/file.document.xlsx` | microsoft excel spreadsheet |
| `meta/file.document.pptx` | microsoft powerpoint presentation |
| `meta/file.document.odt` | opendocument text |
| `meta/file.document.ods` | opendocument spreadsheet |
| `meta/file.document.docx` | Microsoft Word document |
| `meta/file.document.xlsx` | Microsoft Excel spreadsheet |
| `meta/file.document.pptx` | Microsoft PowerPoint presentation |
| `meta/file.document.odt` | OpenDocument text |
| `meta/file.document.ods` | OpenDocument spreadsheet |
| `meta/file.document.epub` | epub e-book |
| `meta/file.document.txt` | plain text file |
| `meta/file.document.md` | markdown document |
| `meta/file.document.pdf` | pdf document |
| `meta/file.document.rtf` | rich text format document |
| `meta/file.document.txt` | Plain text file |
| `meta/file.document.md` | Markdown document |
| `meta/file.document.pdf` | PDF document |
| `meta/file.document.rtf` | Rich Text Format document |
### binaries & executables
### Binaries & executables
| object template | readable name |
| ---------------------- | ---------------------------- |
| `meta/file.binary.exe` | windows executable |
| `meta/file.binary.dll` | dynamic link library |
| `meta/file.binary.ps1` | powershell script |
| `meta/file.binary.bat` | windows batch script |
| `meta/file.binary.sh` | unix shell script |
| `meta/file.binary.elf` | elf binary |
| `meta/file.binary.jar` | java archive |
| `meta/file.binary.apk` | android package |
| `meta/file.binary.iso` | disk image |
| `meta/file.binary.bin` | raw binary |
| template | readable name |
| ---------------------- | -------------------- |
| `meta/file.binary.exe` | Windows executable |
| `meta/file.binary.dll` | Dynamic Link Library |
| `meta/file.binary.ps1` | PowerShell script |
| `meta/file.binary.bat` | Windows batch script |
| `meta/file.binary.sh` | Unix shell script |
| `meta/file.binary.elf` | ELF binary |
| `meta/file.binary.jar` | Java archive |
| `meta/file.binary.apk` | Android package |
| `meta/file.binary.iso` | Disk image |
| `meta/file.binary.bin` | Raw binary |
### archives & compression
| object template | readable name |
| template | readable name |
| ----------------------- | ------------- |
| `meta/file.archive.zip` | zip archive |
| `meta/file.archive.rar` | rar archive |
| `meta/file.archive.zip` | ZIP archive |
| `meta/file.archive.rar` | RAR archive |
| `meta/file.archive.7z` | 7zip archive |
| `meta/file.archive.tar` | tar archive |
| `meta/file.archive.gz` | gzip archive |
| `meta/file.archive.bz2` | bzip2 archive |
| `meta/file.archive.xz` | xz archive |
| `meta/file.archive.xz` | XZ archive |

170
object.md

@ -1,170 +0,0 @@
# objects
**the main unit of organization within the modular object format is the object instance.** an object instance (`wgu::types::ObjectInstance`, stored & transmitted as a [json object literal](https://benalman.com/news/2010/03/theres-no-such-thing-as-a-json/)) is a data structure representing a piece of computer data of a specified type.
core object data is categorized into three categories, `input`, `local`, and `remote`. the structure of these categories depends on the object instance's `object_type`. due to this, wgu stores these categories as *json object strings* in the corresponding columns of the `objects` sqlite table. object metadata (`variant`, `object_type`, timestamps, hashes, etc.) are stored alongside these categories.
the keys in object instances are generally referred to as **properties**.
> **a big pitfall early on is confusing the properties `variant` with `input.variant`.** `variant` is for differentiating between multiple object instances with the same `input_sha256`, while `input.variant` is most often used for defining multiple structures inside one object, when it can represent multiple things (the best example of that is `meta/connection`)
for referencing object instances, the properties `input_sha256` and `variant` are used, separated by a `+` (plus) symbol. to refer to a property within an object:
- add a `:` (colon) symbol
- followed by the category and a `.` (dot) (`input` | `local` | `remote`, unless you're referring to a transform destination, in which case this *must* be ommited as it's always going to be `input`)
- followed by the property name
> **example:** `5aea...b0ca+0:input.value`
if the property you're referring to can be [duplicated](#duplicates), you also have to add the position of the value in the resulting array within `[]` (square brackets):
> **example:** `acab...1312+0:remote.some.thing[2]`
## instances
below are the columns of the table `objects` in wgu's sqlite database. these categories and properties exist for every object.
### categories
| category | transforms | subobjects | conditions | duplicates | purpose |
| -------- | ---------- | ---------- | ---------- | ---------- | ------------------------------------------------------------------ |
| `input` | none | none | none | false | holds data needed for populating properties under other categories |
| `local` | none | none | none | false | holds locally calculated data related to the object instance |
| `remote` | none | none | none | false | holds remotely obtained data related to the object instance |
| `logs` | none | none | none | true | logs produced by functions |
### general
| property | transforms | subobjects | conditions | duplicates | value |
| ------------- | ------------------- | ---------- | ---------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `variant` | `meta/number:value` | none | none | false | for differentiating between multiple objects with the same `hashes.input_sha256`. starts at `0` (zero) for each hash |
| `object_type` | `meta/text:value` | none | none | false | for specifying the object's expected content. the string before the `/` (slash) is the module name, after that `.` (dots) are used to separate layers of nesting |
| `plotted` | `meta/bool:value` | none | none | false | **helper property for wgu.** for specifying if the object is plotted to the main graph view |
### timestamps
> **this section needs more expansion!** you can contribute by documenting how this feature or module operates in the latest available version (also check for pull requests that would change that)
| property | transforms | subobjects | conditions | duplicates | value |
| --------- | ------------------------ | ---------- | ---------- | ---------- | -------------------------------------------- |
| `created` | `meta/timestamp:unix-ms` | none | none | false | timestamp of the object's creation |
| `edited` | `meta/timestamp:unix-ms` | none | none | false | timestamp of the object's last manual edit |
| `hashed` | `meta/timestamp:unix-ms` | none | none | false | timestamp of `input_sha256` being calculated |
### hashing
| property | transforms | subobjects | conditions | duplicates | value |
| -------------- | ----------------- | ---------- | ---------- | ---------- | --------------------------------------------------------------------------------------- |
| `input_sha256` | `meta/text:value` | none | none | false | for naming/querying/referencing objects (together with `variant`) |
| `full_sha256` | `meta/text:value` | none | none | false | for validating/verifying/auditing objects (together with properties under `timestamps`) |
`input_sha256` is calculated as the sha256 checksum of the property `object_type` and properties under `input`, including the start and end braces, separated by `+` (plus) symbols
> **example:** `meta/dummy+{"value":"you are now breathing manually"}` -> `5aea ... b0ca`
`full_sha256` is calculated as the sha256 checksum of the property `object_type`, the timestamp `hashed`, and the categories `input`, `local`, and `remote`, including the start and end braces, separated by `+` (plus) symbols
> **example:** `meta/dummy+1735689600000+{"value":"you are now breathing manually"}+{}+{}` -> `7f17 ... cbdc`
### logs
> **this section needs more expansion!** you can contribute by documenting how this feature or module operates in the latest available version (also check for pull requests that would change that)
| property | transforms | subobjects | conditions | duplicates | value |
| ---------------- | ------------------------ | ---------- | ---------- | ---------- | ------------------------------------------ |
| `logs.level` | `meta/text:value` | none | none | false | can be `error`, `warn`, `info`, or `debug` |
| `logs.variant` | `meta/text:value` | none | none | false | code for the category of the message |
| `logs.timestamp` | `meta/timestamp:unix-ms` | none | none | false | timestamp of the message |
| `logs.message` | `meta/text:value` | none | none | false | human-readable message |
## transforms
a transform is an operation involving taking any property of an object instance, and placing its value into that of a property under `input` of a new object. these are some examples of common transforms:
- existing `meta/text:local.length` -> new `meta/number:value`
- existing `net/url:local.domain` -> new `net/domain:value`
- existing `social/twitter.tweet:remote.posted` -> new `meta/timestamp:unix-ms`
outgoing transforms are defined in the [template of the source object](#transforms-1) under the source property with the destination property, which must always be under `input`.
if an entire object template is used as an outgoing transform, a level of nesting is created within the source property, where the properties under `input` of the destination object template are placed.
similarly, a level of nesting is created if a property's name contains a `.` (dot).
## subobjects
objects can have parent-child relationships with other objects as defined in the parent object's template. this is commonly used when a piece of data is categorized under another in the data source -- these are some examples:
- `social/twitter.tweet` is a subobject of `social/twitter.account`
- `social/discord.message` is a subobject of `social/discord.channel` and `social/discord.thread`
- `web/github.repository` is a subobject of `web/github.user` and `web/github.organization`
similarly to [transforms](#transforms), subobjects are defined in the [template of the parent object](#subobjects-1), along with the shared property (most commonly an identifier). this shared property must have the same [outgoing transforms](#transforms-1) in both the child and parent object.
## templates
**an object template ([`wgu::modules::ModuleItem::Template`](modularity.md#moduleitem-template) is a [toml](https://toml.io) blueprint of an `wgu::types::ObjectInstance`.** templates are used to configure how object instances behave.
for referencing templates, the name of the module and the name of the template are used, separated by a `/` (slash) symbol.
to refer to a property within a template, the same rules apply as with object instances. add a `:` (colon) symbol, followed by the category (`input` | `local` | `remote`, unless you're referring to a transform destination, in which case it's always going to be `input`), followed by a `.` (dot) and the property name, which can be nested with `.` (dots).
> **example:** `meta/text:input.value`
for example, this is the template of the [`meta/dummy`](meta-dummy.md) object type.
```toml
[input.value]
transforms = ["meta/text:value"]
subobjects = []
conditions = []
duplicates = false
```
which then looks like this in the documentation:
| property | transforms | subobjects | conditions | duplicates | value |
| ------------- | ----------------- | ---------- | ---------- | ---------- | ---------------- |
| `input.value` | `meta/text:value` | none | none | false | dummy text value |
### `transforms`
> see also: [transforms](#transforms) in general
array of object types and their properties under `input` that this property transforms to, separated by a `:` (colon) symbol
### `subobjects`
> see also: [subobjects](#subobjects) in general
array of objects and their properties under `input` that this property matches the [outgoing transforms](#transforms-1) of, separated by a `:` (colon) symbol
### `conditions`
must be referring to another property (can be itself). array of values that property must have for this property to be valid in the object instance. **this is mostly there for `input.variant` shenanigans and is NOT to be used for advanced data validation!**
an example would look like this:
```toml
conditions = [
["input.value", "owo"],
["input.variant", "fact-checked by real transgender patriots"]
]
```
if a property is referenced multiple times, all of the provided options will be valid (example from `meta/connection`):
```toml
conditions = [
["input.variant", "function"]
["input.variant", "transform"]
["input.variant", "subobject"]
["input.variant", "custom"]
]
```
### `duplicates`
boolean indicating if this property can be duplicated.
if `true`, the property will be an array when represented in json. this array can contain properties specified in `transforms`. when used as transform destinations, duplicable properties add the source property's value to the first (0th) position, and the remaining positions can be filled later by [calculators](modularity.md#calculator).