snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-docs/l/cs/developers/extend/apps/data/extending-objects.mdx

@@ -0,0 +1,52 @@
+---
+title: Rozšiřování objektů
+description: Přidávejte pole ke standardním objektům Twenty (Person, Company, …) nebo k objektům z jiných aplikací pomocí `defineField`.
+icon: wand-magic-sparkles
+---
+
+Použijte `defineField()` pro přidání pole k objektu, který nevlastníte — standardnímu objektu Twenty, jako je Person nebo Company, nebo objektu dodanému jinou nainstalovanou aplikací. Na rozdíl od inline polí deklarovaných uvnitř [`defineObject`](/l/cs/developers/extend/apps/data/objects) vyžadují samostatná pole `objectUniversalIdentifier` k určení, který objekt rozšiřují.
+
+```ts src/fields/company-loyalty-tier.field.ts
+import { defineField, FieldType } from 'twenty-sdk/define';
+
+export default defineField({
+  universalIdentifier: 'f2a1b3c4-d5e6-7890-abcd-ef1234567890',
+  objectUniversalIdentifier: '701aecb9-eb1c-4d84-9d94-b954b231b64b', // Company object
+  name: 'loyaltyTier',
+  type: FieldType.SELECT,
+  label: 'Loyalty Tier',
+  icon: 'IconStar',
+  options: [
+    { value: 'BRONZE', label: 'Bronze', position: 0, color: 'orange' },
+    { value: 'SILVER', label: 'Silver', position: 1, color: 'gray' },
+    { value: 'GOLD', label: 'Gold', position: 2, color: 'yellow' },
+  ],
+});
+```
+
+## Hlavní body
+
+* `objectUniversalIdentifier` identifikuje cílový objekt. Pro standardní objekty Twenty importujte konstantu z `twenty-sdk`:
+
+  ```ts
+  import { STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS } from 'twenty-sdk/define';
+
+  // STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.company.universalIdentifier
+  // STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.person.universalIdentifier
+  // STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.opportunity.universalIdentifier
+  // …
+  ```
+
+* Při definování polí **inline uvnitř `defineObject()`** `objectUniversalIdentifier` **nepotřebujete** — dědí se z nadřazeného objektu.
+
+* `defineField()` je jediný způsob, jak přidat pole k objektům, které jste nevytvořili pomocí `defineObject()`.
+
+* Umístění souboru je na vás. Konvence je `src/fields/\<name>.field.ts`, ale SDK rozpozná pole kdekoli v `src/`.
+
+* `writability` lze také nastavit pro jednotlivá pole: `MetadataWritability.APPLICATION` omezuje zápisy na logické funkce vaší vlastní aplikace, `MetadataWritability.SYSTEM` je vyhrazeno pro data spravovaná platformou. Zapisovatelnost pole může být pouze přísnější než úroveň jeho objektu a čtení tím nejsou ovlivněna. Úplný popis sémantiky najdete v [Objects](/l/cs/developers/extend/apps/data/objects).
+
+* Chcete-li přidat kartu ke standardnímu rozvržení stránky (např. na detailní stránku Task nebo Company), použijte [`definePageLayoutTab`](/l/cs/developers/extend/apps/layout/page-layouts#definepagelayouttab) s `STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS` z `twenty-sdk/define`.
+
+## Přidání relace k existujícímu objektu
+
+Chcete-li přidat relační pole (např. pro propojení vlastního objektu se standardním `Person`), použijte `defineField()` s `FieldType.RELATION`. Vzor je stejný jako u inline relací, ale s `objectUniversalIdentifier` nastaveným explicitně. Obousměrný vzor najdete v části [Relations](/l/cs/developers/extend/apps/data/relations).

packages/twenty-docs/l/cs/developers/extend/apps/data/objects.mdx

@@ -0,0 +1,143 @@
+---
+title: Objekty
+description: Deklarujte nové typy záznamů – vlastní tabulky s jejich vlastními poli – pomocí defineObject.
+icon: table
+---
+
+Vlastní **objekty** jsou nové typy záznamů, které vaše aplikace přidává do pracovního prostoru — pohlednice, faktura, předplatné, cokoli specifického pro vaši doménu. Každý objekt definuje své schéma (pole, vztahy, výchozí hodnoty) a stabilní univerzální identifikátor, který přetrvá mezi synchronizacemi a nasazeními.
+
+```ts src/objects/post-card.object.ts
+import { defineObject, FieldType } from 'twenty-sdk/define';
+
+enum PostCardStatus {
+  DRAFT = 'DRAFT',
+  SENT = 'SENT',
+  DELIVERED = 'DELIVERED',
+  RETURNED = 'RETURNED',
+}
+
+export default defineObject({
+  universalIdentifier: '54b589ca-eeed-4950-a176-358418b85c05',
+  nameSingular: 'postCard',
+  namePlural: 'postCards',
+  labelSingular: 'Post Card',
+  labelPlural: 'Post Cards',
+  description: 'A post card object',
+  icon: 'IconMail',
+  fields: [
+    {
+      universalIdentifier: '58a0a314-d7ea-4865-9850-7fb84e72f30b',
+      name: 'content',
+      type: FieldType.TEXT,
+      label: 'Content',
+      description: "Postcard's content",
+      icon: 'IconAbc',
+    },
+    {
+      universalIdentifier: 'c6aa31f3-da76-4ac6-889f-475e226009ac',
+      name: 'recipientName',
+      type: FieldType.FULL_NAME,
+      label: 'Recipient name',
+      icon: 'IconUser',
+    },
+    {
+      universalIdentifier: '95045777-a0ad-49ec-98f9-22f9fc0c8266',
+      name: 'recipientAddress',
+      type: FieldType.ADDRESS,
+      label: 'Recipient address',
+      icon: 'IconHome',
+    },
+    {
+      universalIdentifier: '87b675b8-dd8c-4448-b4ca-20e5a2234a1e',
+      name: 'status',
+      type: FieldType.SELECT,
+      label: 'Status',
+      icon: 'IconSend',
+      defaultValue: `'${PostCardStatus.DRAFT}'`,
+      options: [
+        { value: PostCardStatus.DRAFT, label: 'Draft', position: 0, color: 'gray' },
+        { value: PostCardStatus.SENT, label: 'Sent', position: 1, color: 'orange' },
+        { value: PostCardStatus.DELIVERED, label: 'Delivered', position: 2, color: 'green' },
+        { value: PostCardStatus.RETURNED, label: 'Returned', position: 3, color: 'orange' },
+      ],
+    },
+    {
+      universalIdentifier: 'e06abe72-5b44-4e7f-93be-afc185a3c433',
+      name: 'deliveredAt',
+      type: FieldType.DATE_TIME,
+      label: 'Delivered at',
+      icon: 'IconCheck',
+      isNullable: true,
+      defaultValue: null,
+    },
+  ],
+});
+```
+
+## Hlavní body
+
+* Hodnota `universalIdentifier` musí být jedinečná a stabilní napříč nasazeními.
+* Každé pole vyžaduje `name`, `type`, `label` a svůj vlastní stabilní `universalIdentifier`.
+* Pole `fields` je volitelné — objekty můžete definovat i bez vlastních polí.
+* `openRecordIn` určuje, kde se záznamy tohoto objektu otevřou po kliknutí: `ObjectOpenRecordIn.USER_CHOICE` (výchozí nastavení, které respektuje individuální předvolbu každého člena pracovního prostoru v Settings → Experience), `ObjectOpenRecordIn.SIDE_PANEL` nebo `ObjectOpenRecordIn.RECORD_PAGE`. Připněte jej k `RECORD_PAGE` pro záznamy, které ke svému používání potřebují celou stránku, stejně jako pracovní postupy a řídicí panely, nebo k `SIDE_PANEL` pro záznamy, které dávají smysl jen jako rychlý panel, podobně jako události v kalendáři.
+* `writability` určuje, kdo vůbec smí zapisovat záznamy objektu, ještě předtím, než se uplatní oprávnění rolí: `MetadataWritability.OPEN` (výchozí – rozhodují role ve workspace), `MetadataWritability.APPLICATION` (záznamy mohou vytvářet, aktualizovat nebo mazat pouze logické funkce samotné aplikace; použijte pro objekty podobné konfiguraci, jejichž záznamy určují chování, aby je členové workspace s širokým přístupem k záznamům nemohli upravovat přes API) nebo `MetadataWritability.SYSTEM` (vyhrazeno pro data spravovaná platformou). Čtení nejsou ovlivněna – toto je vynucováno na straně serveru, na rozdíl od `isUIEditable`, které pouze skrývá prvky uživatelského rozhraní. Existuje také na úrovni jednotlivých polí, kde může být pouze přísnější než na úrovni objektu.
+* Pole definovaná zde inline **nepotřebují** `objectUniversalIdentifier` — dědí se z nadřazeného objektu. Pomocí [`defineField()`](/l/cs/developers/extend/apps/data/extending-objects) můžete přidávat pole k objektům, které nevlastníte.
+* Nové objekty můžete vygenerovat pomocí `yarn twenty dev:add object`, který vás provede pojmenováním, poli a vztahy. Viz [Architektura → Scaffolding entit](/l/cs/developers/extend/apps/getting-started/scaffolding).
+
+<Note>
+**Základní pole jsou přidána automaticky.** Když definujete vlastní objekt, Twenty pro vás vytvoří standardní pole jako `id`, `name`, `createdAt`, `updatedAt`, `createdBy`, `updatedBy` a `deletedAt`. Nemusíte je uvádět v poli `fields` — pouze svá vlastní pole. Výchozí pole můžete přepsat tak, že deklarujete pole se stejným názvem, ale jen zřídka je to dobrý nápad.
+</Note>
+
+## Typy polí
+
+Úplná sada hodnot `FieldType`, exportovaných z `twenty-sdk/define`:
+
+| Kategorie               | Typy                                                                                                                            |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| Text                    | `TEXT`, `RICH_TEXT`, `ARRAY` (řetězců), `RAW_JSON`                                                                              |
+| Číselné                 | `NUMBER` (`universalSettings.dataType`: `'float'` / `'int'` / `'bigint'`), `NUMERIC` (libovolná přesnost), `RATING`, `POSITION` |
+| Datumy                  | `DATE`, `DATE_TIME`                                                                                                             |
+| Výběr                   | `BOOLEAN`, `SELECT`, `MULTI_SELECT`                                                                                             |
+| Složené                 | `FULL_NAME`, `ADDRESS`, `EMAILS`, `PHONES`, `LINKS`, `CURRENCY`, `ACTOR`, `FILES`                                               |
+| Identifikátory a relace | `UUID`, `RELATION`, `MORPH_RELATION` (viz [Relations](/l/cs/developers/extend/apps/data/relations))                                  |
+| Systém                  | `TS_VECTOR` (vektor pro fulltextové vyhledávání, spravovaný serverem)                                                           |
+
+Složené typy ukládají více podpolí (např. `FULL_NAME` = křestní jméno + příjmení; `CURRENCY` = `amountMicros` + `currencyCode`). `SELECT` a `MULTI_SELECT` vyžadují pole `options`, jak je ukázáno v příkladu výše.
+
+## Výchozí hodnoty
+
+Výchozí textové hodnoty musí být uzavřené v jednoduchých uvozovkách **uvnitř** řetězce — `defaultValue: "'Draft'"`, ne `defaultValue: "Draft"`. Proto pole `status` výše používá `` `'${PostCardStatus.DRAFT}'` ``.
+
+Neuzavřené (necitované) řetězce jsou vyhrazené pro vypočítané výchozí hodnoty, které se vyhodnocují při vytvoření záznamu:
+
+* `'uuid'` — generuje UUID (pro pole `UUID`)
+* `'now'` — aktuální časové razítko (pro pole `DATE_TIME`)
+
+Stejná konvence platí pro řetězcová podpola složených výchozích hodnot (např. `{ source: "'MANUAL'" }` u pole `ACTOR`) a pro hodnoty `SELECT`/`MULTI_SELECT`. Doslovná řetězcová výchozí hodnota ponechaná bez uvozovek vyvolá při sestavení aplikace varování.
+
+## Možnost hodnoty NULL
+
+`isNullable` určuje, zda pole přijímá `NULL`. Výchozí hodnota je `true` — pro volitelná pole ji můžete vynechat. Nastavte `isNullable: false`, aby bylo pole vyžadováno na úrovni databáze.
+
+Změny `isNullable` se použijí při každé synchronizaci, včetně těch, které aktualizují existující pole — takže můžete změnit, zda pole přijímá hodnotu NULL, úpravou manifestu a opětovnou synchronizací.
+
+<Note>
+**Změna existujícího pole tak, aby neumožňovalo hodnotu NULL, vyžaduje výchozí hodnotu.** Když změníte pole na `isNullable: false`, musíte také zadat nenulovou hodnotu `defaultValue`. Výchozí hodnota doplní všechny existující řádky s hodnotou `NULL` ještě předtím, než se uplatní omezení `NOT NULL`; bez ní synchronizace selže s chybou `Default value cannot be null for non-nullable fields`. Relační pole a pole typu `TS_VECTOR` vždy umožňují hodnotu NULL, takže na ně `isNullable` nemá žádný efekt.
+</Note>
+
+```ts
+{
+  universalIdentifier: 'b1a7c0de-1234-4f00-9abc-000000000000',
+  name: 'reference',
+  type: FieldType.TEXT,
+  label: 'Reference',
+  isNullable: false,
+  defaultValue: "'N/A'",
+}
+```
+
+## Co dál
+
+* **Propojte tento objekt s ostatními** — vzor obousměrných vztahů najdete v části [Relations](/l/cs/developers/extend/apps/data/relations).
+* **Přidávejte pole k objektům z jiných aplikací** — viz [Extending Objects](/l/cs/developers/extend/apps/data/extending-objects) pro `defineField()`.
+* **Zobrazit tento objekt v uživatelském rozhraní** — viz [Položky navigační nabídky](/l/cs/developers/extend/apps/layout/navigation-menu-items) pro přidání položky do postranního panelu; viz [Zobrazení](/l/cs/developers/extend/apps/layout/views) pro přidání vlastních konfigurací seznamu.

packages/twenty-docs/l/cs/developers/extend/apps/data/overview.mdx

@@ -0,0 +1,101 @@
+---
+title: Přehled
+description: Formujte data, která vaše aplikace přidává do pracovního prostoru — objekty, pole a vztahy.
+icon: database
+---
+
+**Datová vrstva** aplikace Twenty představuje data, která vaše aplikace *přidává* do pracovního prostoru — nové typy záznamů, které deklaruje, sloupce, které přidává k existujícím objektům a způsob, jakým se tyto záznamy vzájemně propojují.
+
+```text
+┌──────────────────────────────────────────────────┐
+│ Object — a record type, e.g. PostCard            │
+│    ├─ Field     (name, type, label)              │
+│    ├─ Field                                      │
+│    └─ Relation  (link to another object)         │
+└──────────────────────────────────────────────────┘
+            │
+            ├── lives in your app, OR
+            │
+            ▼
+┌──────────────────────────────────────────────────┐
+│ Standard / other apps' objects                   │
+│    └─ Field added by your app via defineField    │
+└──────────────────────────────────────────────────┘
+```
+
+## V této části
+
+<CardGroup cols={2}>
+  <Card title="Objekty" icon="table" href="/l/cs/developers/extend/apps/data/objects">
+    `defineObject` — deklarujte nové typy záznamů s jejich vlastními poli.
+  </Card>
+  <Card title="Rozšiřování objektů" icon="wand-magic-sparkles" href="/l/cs/developers/extend/apps/data/extending-objects">
+    `defineField` — přidejte pole ke standardním objektům nebo objektům jiných aplikací.
+  </Card>
+  <Card title="Vztahy" icon="diagram-project" href="/l/cs/developers/extend/apps/data/relations">
+    Obousměrná `MANY_TO_ONE` / `ONE_TO_MANY` propojení mezi objekty.
+  </Card>
+  <Card title="Typy aktivit na časové ose" icon="clock-rotate-left" href="/l/cs/developers/extend/apps/data/timeline-activity-types">
+    Definujte automatické události auditu a explicitní události aplikace pro časové osy záznamů.
+  </Card>
+</CardGroup>
+
+## Entity v kostce
+
+| Entita                         | Účel                                                                                                                               | Definováno pomocí                      |
+| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- |
+| **Objekt**                     | Nový vlastní typ záznamu (např. PostCard, Invoice) s vlastními poli                                                                | `defineObject()`                       |
+| **Pole**                       | Sloupec v objektu. Samostatná pole mohou rozšiřovat objekty, které jste nevytvořili (např. přidat `loyaltyTier` k objektu Company) | `defineField()`                        |
+| **Vztah**                      | Obousměrné propojení mezi dvěma objekty — obě strany deklarované jako pole                                                         | `defineField()` s `FieldType.RELATION` |
+| **Index**                      | Databázový index pro zrychlení opakovaného dotazu na jeden z vašich objektů                                                        | `defineIndex()`                        |
+| **Typ aktivity na časové ose** | Automatická událost auditu nebo explicitní událost domény zobrazená na časových osách záznamů                                      | `defineTimelineActivityType()`         |
+
+SDK je detekuje pomocí analýzy AST v době buildu, takže organizace souborů je na vás — zažitou konvencí je `src/objects/`, `src/fields/`, `src/indexes/` a `src/timeline-activity-types/`. Stabilní UUID `universalIdentifier` vše propojují napříč nasazeními.
+
+## Indexy (volitelné)
+
+Aplikace mohou dodávat indexy společně se svými objekty, aby udržely opakované dotazy rychlými. Nejčastějším případem je sloupec se stavem nebo cizím klíčem, který často čtete.
+
+```ts src/indexes/post-card-status.index.ts
+import { defineIndex } from 'twenty-sdk/define';
+
+import {
+  POST_CARD_UNIVERSAL_IDENTIFIER,
+  STATUS_FIELD_UNIVERSAL_IDENTIFIER,
+} from '../objects/post-card.object';
+
+export default defineIndex({
+  universalIdentifier: 'b6e9d2a1-5a4c-46ca-9d52-42c8f02d1ff0',
+  objectUniversalIdentifier: POST_CARD_UNIVERSAL_IDENTIFIER,
+  fields: [
+    {
+      universalIdentifier: 'b6e9d2a1-5a4c-46ca-9d52-42c8f02d1ff1',
+      fieldUniversalIdentifier: STATUS_FIELD_UNIVERSAL_IDENTIFIER,
+    },
+  ],
+});
+```
+
+### Jedinečné indexy
+
+`defineIndex` přijímá `isUnique: true` jak pro jedinečnost jednoho sloupce, tak vícesloupcovou jedinečnost. Toto je doporučené primitivum — `defineField({ isUnique: true })` je zastaralé a bude odstraněno v některém z příštích vydání.
+
+```ts
+defineIndex({
+  universalIdentifier: '…',
+  objectUniversalIdentifier: PERSON_UNIVERSAL_IDENTIFIER,
+  isUnique: true,
+  fields: [{ universalIdentifier: '…', fieldUniversalIdentifier: EMAIL_FIELD_UNIVERSAL_IDENTIFIER }],
+});
+```
+
+### Další omezení
+
+* Částečné klauzule `WHERE` zůstávají pod kontrolou administrátora — aplikace je nemohou deklarovat.
+* Každý objekt je omezen na 10 vlastních indexů (indexy samotného frameworku se nepočítají).
+
+Seřaďte pole `fields` tak, jak je má Postgres používat — nejlevější sloupec jako první, jako v telefonním seznamu. Indexy nejsou zadarmo: každý zápis do tabulky je aktualizuje. Přidávejte je jen tehdy, když máte dotaz, který je potřebuje.
+
+<Note>
+Hledáte **Application Config** nebo **Roles & Permissions**? Ty popisují samotnou aplikaci, nikoli data, která přidává — najdete je pod [Config](/l/cs/developers/extend/apps/config/overview). Hledáte **Connections** (Linear, GitHub, Slack OAuth)? Ty existují proto, aby byly volány *z* logických funkcí, a najdete je pod [Logic](/l/cs/developers/extend/apps/logic/connections).
+</Note>

packages/twenty-docs/l/cs/developers/extend/apps/data/relations.mdx

@@ -0,0 +1,184 @@
+---
+title: Vztahy
+description: Propojte objekty obousměrnými relacemi MANY_TO_ONE / ONE_TO_MANY.
+icon: diagram-project
+---
+
+Relace propojují dva objekty. Ve Twenty jsou relace vždy **obousměrné** — každá relace má dvě strany a každá strana je deklarována jako pole, které odkazuje na tu druhou.
+
+| Typ vztahu    | Popis                                                                 | Má cizí klíč?          |
+| ------------- | --------------------------------------------------------------------- | ---------------------- |
+| `MANY_TO_ONE` | Mnoho záznamů tohoto objektu ukazuje na jeden záznam cílového objektu | Ano (`joinColumnName`) |
+| `ONE_TO_MANY` | Jeden záznam tohoto objektu má mnoho záznamů cílového objektu         | Ne (inverzní strana)   |
+
+## Jak fungují relace
+
+Každá relace vyžaduje dvě pole, která na sebe vzájemně odkazují:
+
+1. Strana MANY_TO_ONE — je na objektu, který drží cizí klíč.
+2. Strana ONE_TO_MANY — je na objektu, který vlastní kolekci.
+
+Obě pole používají `FieldType.RELATION` a vzájemně se odkazují prostřednictvím `relationTargetFieldMetadataUniversalIdentifier`.
+
+## Příklad: Pohlednice má mnoho příjemců
+
+`PostCard` lze odeslat mnoha záznamům `PostCardRecipient`. Každý příjemce náleží přesně jedné pohlednici.
+
+**Krok 1: Definujte stranu ONE_TO_MANY na PostCard** (strana "one"):
+
+```ts src/fields/post-card-recipients-on-post-card.field.ts
+import { defineField, FieldType, RelationType } from 'twenty-sdk/define';
+import { POST_CARD_UNIVERSAL_IDENTIFIER } from '../objects/post-card.object';
+import { POST_CARD_RECIPIENT_UNIVERSAL_IDENTIFIER } from '../objects/post-card-recipient.object';
+
+// Export so the other side can reference it
+export const POST_CARD_RECIPIENTS_FIELD_ID = 'a1111111-1111-1111-1111-111111111111';
+// Import from the other side
+import { POST_CARD_FIELD_ID } from './post-card-on-post-card-recipient.field';
+
+export default defineField({
+  universalIdentifier: POST_CARD_RECIPIENTS_FIELD_ID,
+  objectUniversalIdentifier: POST_CARD_UNIVERSAL_IDENTIFIER,
+  type: FieldType.RELATION,
+  name: 'postCardRecipients',
+  label: 'Post Card Recipients',
+  icon: 'IconUsers',
+  relationTargetObjectMetadataUniversalIdentifier: POST_CARD_RECIPIENT_UNIVERSAL_IDENTIFIER,
+  relationTargetFieldMetadataUniversalIdentifier: POST_CARD_FIELD_ID,
+  universalSettings: {
+    relationType: RelationType.ONE_TO_MANY,
+  },
+});
+```
+
+**Krok 2: Definujte stranu MANY_TO_ONE na PostCardRecipient** (strana "many" — drží cizí klíč):
+
+```ts src/fields/post-card-on-post-card-recipient.field.ts
+import { defineField, FieldType, RelationType, OnDeleteAction } from 'twenty-sdk/define';
+import { POST_CARD_UNIVERSAL_IDENTIFIER } from '../objects/post-card.object';
+import { POST_CARD_RECIPIENT_UNIVERSAL_IDENTIFIER } from '../objects/post-card-recipient.object';
+
+// Export so the other side can reference it
+export const POST_CARD_FIELD_ID = 'b2222222-2222-2222-2222-222222222222';
+// Import from the other side
+import { POST_CARD_RECIPIENTS_FIELD_ID } from './post-card-recipients-on-post-card.field';
+
+export default defineField({
+  universalIdentifier: POST_CARD_FIELD_ID,
+  objectUniversalIdentifier: POST_CARD_RECIPIENT_UNIVERSAL_IDENTIFIER,
+  type: FieldType.RELATION,
+  name: 'postCard',
+  label: 'Post Card',
+  icon: 'IconMail',
+  relationTargetObjectMetadataUniversalIdentifier: POST_CARD_UNIVERSAL_IDENTIFIER,
+  relationTargetFieldMetadataUniversalIdentifier: POST_CARD_RECIPIENTS_FIELD_ID,
+  universalSettings: {
+    relationType: RelationType.MANY_TO_ONE,
+    onDelete: OnDeleteAction.CASCADE,
+    joinColumnName: 'postCardId',
+  },
+});
+```
+
+<Note>
+**Cyklické importy:** obě relační pole odkazují na `universalIdentifier` toho druhého. Abyste předešli problémům s cyklickými importy, exportujte ID polí jako pojmenované konstanty z každého souboru a v druhém je importujte. Build systém je vyřeší v době kompilace.
+</Note>
+
+## Propojovací vztahy
+
+Propojovací objekt spojuje jeden zdrojový záznam s jedním nebo více cílovými záznamy. Například `PostCardRecipient` může obsahovat vztah `postCard` i vztah `recipient`. V poli `ONE_TO_MANY` zdrojového objektu nastavte `junctionTargetFieldUniversalIdentifier` na pole vztahu v propojovacím objektu, které ukazuje na cíl:
+
+```ts
+export default defineField({
+  universalIdentifier: POST_CARD_RECIPIENTS_FIELD_ID,
+  objectUniversalIdentifier: POST_CARD_UNIVERSAL_IDENTIFIER,
+  type: FieldType.RELATION,
+  name: 'postCardRecipients',
+  label: 'Post Card Recipients',
+  relationTargetObjectMetadataUniversalIdentifier:
+    POST_CARD_RECIPIENT_UNIVERSAL_IDENTIFIER,
+  relationTargetFieldMetadataUniversalIdentifier: POST_CARD_FIELD_ID,
+  universalSettings: {
+    relationType: RelationType.ONE_TO_MANY,
+    junctionTargetFieldUniversalIdentifier: RECIPIENT_FIELD_ID,
+  },
+});
+```
+
+`RECIPIENT_FIELD_ID` musí identifikovat vztah `MANY_TO_ONE` nebo morfní vztah v propojovacím objektu. Systému Twenty udává, který související záznam je cílem, když funkce, jako je [rozvětvení aktivity časové osy](/l/cs/developers/extend/apps/data/timeline-activity-types#automatic-and-explicit-events), prochází propojovacím objektem.
+
+## Vazby na standardní objekty
+
+Chcete-li vytvořit relaci s vestavěným objektem Twenty (Person, Company atd.), použijte `STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS`:
+
+```ts src/fields/person-on-self-hosting-user.field.ts
+import {
+  defineField,
+  FieldType,
+  RelationType,
+  OnDeleteAction,
+  STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS,
+} from 'twenty-sdk/define';
+import { SELF_HOSTING_USER_UNIVERSAL_IDENTIFIER } from '../objects/self-hosting-user.object';
+
+export const PERSON_FIELD_ID = 'c3333333-3333-3333-3333-333333333333';
+export const SELF_HOSTING_USER_REVERSE_FIELD_ID = 'd4444444-4444-4444-4444-444444444444';
+
+export default defineField({
+  universalIdentifier: PERSON_FIELD_ID,
+  objectUniversalIdentifier: SELF_HOSTING_USER_UNIVERSAL_IDENTIFIER,
+  type: FieldType.RELATION,
+  name: 'person',
+  label: 'Person',
+  description: 'Person matching with the self hosting user',
+  isNullable: true,
+  relationTargetObjectMetadataUniversalIdentifier:
+    STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.person.universalIdentifier,
+  relationTargetFieldMetadataUniversalIdentifier: SELF_HOSTING_USER_REVERSE_FIELD_ID,
+  universalSettings: {
+    relationType: RelationType.MANY_TO_ONE,
+    onDelete: OnDeleteAction.SET_NULL,
+    joinColumnName: 'personId',
+  },
+});
+```
+
+## Vlastnosti relačních polí
+
+| Vlastnost                                                  | Povinné                           | Popis                                                                                             |
+| ---------------------------------------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `type`                                                     | Ano                               | Musí být `FieldType.RELATION`                                                                     |
+| `relationTargetObjectMetadataUniversalIdentifier`          | Ano                               | `universalIdentifier` cílového objektu                                                            |
+| `relationTargetFieldMetadataUniversalIdentifier`           | Ano                               | `universalIdentifier` odpovídajícího pole na cílovém objektu                                      |
+| `universalSettings.relationType`                           | Ano                               | `RelationType.MANY_TO_ONE` nebo `RelationType.ONE_TO_MANY`                                        |
+| `universalSettings.onDelete`                               | Pouze MANY_TO_ONE                 | Co se stane, když je smazán odkazovaný záznam: `CASCADE`, `SET_NULL`, `RESTRICT` nebo `NO_ACTION` |
+| `universalSettings.joinColumnName`                         | Pouze MANY_TO_ONE                 | Název databázového sloupce pro cizí klíč (např. `postCardId`)                                     |
+| `universalSettings.junctionTargetFieldUniversalIdentifier` | Pouze pro propojovací ONE_TO_MANY | Pole vztahu v propojovacím objektu, které ukazuje na cíl rozvětvení                               |
+
+## Vložená relační pole
+
+Relaci můžete také deklarovat přímo uvnitř [`defineObject`](/l/cs/developers/extend/apps/data/objects). Pokud je pole vložené, vynechejte `objectUniversalIdentifier` — dědí se z nadřazeného objektu:
+
+```ts
+export default defineObject({
+  universalIdentifier: '...',
+  nameSingular: 'postCardRecipient',
+  // ...
+  fields: [
+    {
+      universalIdentifier: POST_CARD_FIELD_ID,
+      type: FieldType.RELATION,
+      name: 'postCard',
+      label: 'Post Card',
+      relationTargetObjectMetadataUniversalIdentifier: POST_CARD_UNIVERSAL_IDENTIFIER,
+      relationTargetFieldMetadataUniversalIdentifier: POST_CARD_RECIPIENTS_FIELD_ID,
+      universalSettings: {
+        relationType: RelationType.MANY_TO_ONE,
+        onDelete: OnDeleteAction.CASCADE,
+        joinColumnName: 'postCardId',
+      },
+    },
+    // … other fields
+  ],
+});
+```

packages/twenty-docs/l/cs/developers/extend/apps/data/system-fields.mdx

@@ -0,0 +1,212 @@
+---
+title: Cílení na systémová metadata
+description: Vyřešte deterministické univerzální identifikátory metadat, která Twenty automaticky zřizuje u každého objektu, aby se na ně vaše aplikace mohla odkazovat bez hardcodování.
+icon: gears
+---
+
+Každý objekt v Twenty má **systémová metadata**, která sami nedefinujete, například sadu polí a hlavní zobrazení seznamu s jeho sloupci. Server všechno vytvoří při zřízení objektu a tato sada roste spolu s tím, jak roste Twenty.
+
+Protože je nedefinujete, neexistuje žádná konstanta `universalIdentifier`, kterou byste mohli importovat. Místo toho server každý identifikátor **odvozuje** deterministicky a `twenty-sdk` zpřístupňuje stejné odvozování, takže váš manifest může zjistit přesnou hodnotu, kterou server používá.
+
+## Systémová pole
+
+Skalární pole přítomná na každém objektu, z nichž žádné nedefinujete pomocí [`defineField()`](/l/cs/developers/extend/apps/data/extending-objects):
+
+`id`, `createdAt`, `updatedAt`, `deletedAt`, `createdBy`, `updatedBy`, `position`, `searchVector`
+
+Jak tedy odkážete na `createdAt` jako na sloupec ve [zobrazení](/l/cs/developers/extend/apps/layout/views)?
+
+### Problém
+
+Od Twenty 2.19 je univerzální identifikátor systémového pole **deterministicky odvozován** serverem ze tří vstupů: univerzálního identifikátoru aplikace, univerzálního identifikátoru objektu a názvu pole. Vymyslet si id a natvrdo ho zapsat nebude fungovat: neshoduje se s ničím na serveru a synchronizace zamítne osiřelý odkaz:
+
+```
+Dev sync failed: viewField: INVALID_VIEW_DATA: Field metadata not found
+```
+
+### Řešení
+
+<Note>
+  `getFieldUniversalIdentifier` je k dispozici od `twenty-sdk` verze 2.21 a vyšší.
+</Note>
+
+Použijte `getFieldUniversalIdentifier` k odvození přesně stejné hodnoty, jakou používá server. Funkce přijímá tři vstupy a vrací univerzální identifikátor pole:
+
+```ts
+import { getFieldUniversalIdentifier } from 'twenty-sdk/define';
+
+const createdAtFieldId = getFieldUniversalIdentifier({
+  applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+  objectUniversalIdentifier: MY_OBJECT_UNIVERSAL_IDENTIFIER,
+  name: 'createdAt',
+});
+```
+
+* `applicationUniversalIdentifier` je identifikátor vaší aplikace, ten, který předáváte do [`defineApplication()`](/l/cs/developers/extend/apps/config/application).
+* `objectUniversalIdentifier` je identifikátor objektu, ke kterému pole patří.
+* `name` je název systémového pole, jedna z výše uvedených hodnot.
+
+### Příklad: sloupec createdAt v zobrazení
+
+Typickým případem je přidání sloupce `createdAt` do zobrazení některého z vašich vlastních objektů. Odvoďte identifikátor pole a odkažte na něj stejně jako na jakýkoli jiný `fieldMetadataUniversalIdentifier`:
+
+```ts src/views/example-view.ts
+import {
+  defineView,
+  getFieldUniversalIdentifier,
+} from 'twenty-sdk/define';
+
+const APPLICATION_UNIVERSAL_IDENTIFIER =
+  '0b04e15c-27b2-4741-9046-b32e07469072';
+const MY_OBJECT_UNIVERSAL_IDENTIFIER =
+  'c782b61c-70fd-4c88-9cd6-4e61ab8d7591';
+
+export default defineView({
+  universalIdentifier: '70f10d44-144a-4da8-8c6f-3ec2422138c0',
+  name: 'All records',
+  objectUniversalIdentifier: MY_OBJECT_UNIVERSAL_IDENTIFIER,
+  icon: 'IconList',
+  position: 0,
+  fields: [
+    {
+      universalIdentifier: '75a90bc4-d901-4df4-85e0-af29db5e0104',
+      fieldMetadataUniversalIdentifier: getFieldUniversalIdentifier({
+        applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+        objectUniversalIdentifier: MY_OBJECT_UNIVERSAL_IDENTIFIER,
+        name: 'createdAt',
+      }),
+      position: 0,
+      isVisible: true,
+      size: 200,
+    },
+  ],
+});
+```
+
+Tentýž odvozený identifikátor funguje všude tam, kde se očekává `fieldMetadataUniversalIdentifier`: pole zobrazení, filtry, řazení, seskupování a widgety rozložení stránky.
+
+<Note>
+  Identifikátor odvozujte, neukládejte ho natvrdo. Protože server odvozuje hodnotu z
+  ID aplikace, ID objektu a názvu pole, volání
+  `getFieldUniversalIdentifier` udržuje odkaz správný i v případě, že se tyto
+  vstupy změní, a předchází odchylkám, pokud se samotný způsob odvozování někdy změní.
+</Note>
+
+### Systémová relační pole
+
+<Note>
+  `getSystemRelationFieldUniversalIdentifier` je k dispozici od verze `twenty-sdk`
+  2.23 a vyžaduje server Twenty ve verzi 2.23 nebo novější.
+</Note>
+
+Kromě výše uvedených skalárních systémových polí server také na každém objektu poskytuje čtyři **systémová relační pole**: `timelineActivities`, `attachments`, `noteTargets` a `taskTargets`, z nichž každé ukazuje na odpovídající standardní relační objekt.
+
+Tato pole nejsou řešena pomocí `getFieldUniversalIdentifier`: jejich identifikátor je odvozen **bez ohledu na název** z objektu, který pole obsahuje, a z objektu, na který pole odkazuje. Tím pádem přejmenování objektu nikdy nezmění identifikátory jeho relačních polí.
+
+Použijte `getSystemRelationFieldUniversalIdentifier` k jejich vyřešení:
+
+```ts
+import {
+  getSystemRelationFieldUniversalIdentifier,
+  STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS,
+} from 'twenty-sdk/define';
+
+// rocket.attachments — the relation field hosted on your custom object
+const rocketAttachmentsFieldId = getSystemRelationFieldUniversalIdentifier({
+  applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+  objectUniversalIdentifier: ROCKET_OBJECT_UNIVERSAL_IDENTIFIER,
+  relationTargetObjectUniversalIdentifier:
+    STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.attachment.universalIdentifier,
+});
+```
+
+* `objectUniversalIdentifier` je objekt, který toto pole **obsahuje**.
+* `relationTargetObjectUniversalIdentifier` je objekt, na který toto pole **ukazuje**.
+
+Směr je zakódovaný pořadím argumentů. Pro vyřešení opačné strany (např. `attachment.targetRocket`, morph pole, které server vytvoří na standardním relačním objektu), je prohoďte:
+
+```ts
+// attachment.targetRocket — the reverse morph field on Attachment
+const attachmentTargetRocketFieldId =
+  getSystemRelationFieldUniversalIdentifier({
+    applicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+    objectUniversalIdentifier:
+      STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.attachment.universalIdentifier,
+    relationTargetObjectUniversalIdentifier: ROCKET_OBJECT_UNIVERSAL_IDENTIFIER,
+  });
+```
+
+Stejně jako u skalárních systémových polí funguje vyřešené ID všude tam, kde je očekáváno `fieldMetadataUniversalIdentifier`.
+
+## Systémová zobrazení
+
+<Note>
+  `getSystemViewUniversalIdentifier` a `getSystemViewFieldUniversalIdentifier`
+  jsou k dispozici od verze `twenty-sdk` 2.26 a vyžadují server Twenty ve
+  verzi 2.26 nebo novější.
+</Note>
+
+Server také pro každý objekt zřizuje **systémové zobrazení**: hlavní zobrazení seznamu (`All {objectLabelPlural}`, s klíčem `ViewKey.INDEX` (odvozeným pomocí `SYSTEM_VIEW_KEYS.INDEX`)), s jedním sloupcem pro každé zobrazitelné pole. Stejně jako u systémových relačních polí jsou jejich identifikátory odvozovány **nezávisle na názvu**, takže přejmenování objektu nebo pole je nikdy nezmění.
+
+Použijte `getSystemViewUniversalIdentifier` k vyřešení zobrazení:
+
+```ts
+import {
+  getSystemViewUniversalIdentifier,
+  SYSTEM_VIEW_KEYS,
+} from 'twenty-sdk/define';
+
+const rocketIndexViewId = getSystemViewUniversalIdentifier({
+  objectMetadataApplicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+  objectUniversalIdentifier: ROCKET_OBJECT_UNIVERSAL_IDENTIFIER,
+  viewKey: SYSTEM_VIEW_KEYS.INDEX,
+});
+```
+
+* `objectMetadataApplicationUniversalIdentifier` je aplikace, která vlastní **objekt**, podle které je zobrazení namespacované.
+* `objectUniversalIdentifier` je objekt, který zobrazení vypisuje.
+* `viewKey` je diskriminátor systémového zobrazení: `SYSTEM_VIEW_KEYS.INDEX` pro hlavní zobrazení seznamu, `SYSTEM_VIEW_KEYS.FIELDS_WIDGET` pro zobrazení widgetu polí na stránce záznamu. Určuje klíč pro odvozování; pouze `INDEX` je také uložen v řádku zobrazení.
+
+Vyhodnocené ID funguje všude tam, kde se očekává `viewUniversalIdentifier`, například u položky postranního panelu [`NavigationMenuItemType.VIEW`](/l/cs/developers/extend/apps/layout/navigation-menu-items). Pro pouhé otevření hlavního seznamu objektu preferujte `NavigationMenuItemType.OBJECT` s `targetObjectUniversalIdentifier`: nevyžaduje žádné odvozování.
+
+`getSystemViewFieldUniversalIdentifier` vyhodnotí jeden konkrétní **sloupec** v systémovém zobrazení na základě zobrazení a pole, které zobrazuje:
+
+```ts
+import { getSystemViewFieldUniversalIdentifier } from 'twenty-sdk/define';
+
+const rocketNameColumnId = getSystemViewFieldUniversalIdentifier({
+  fieldMetadataApplicationUniversalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+  viewUniversalIdentifier: rocketIndexViewId,
+  fieldMetadataUniversalIdentifier: ROCKET_NAME_FIELD_UNIVERSAL_IDENTIFIER,
+});
+```
+
+Všimněte si prvního argumentu: sloupec je namespacován podle aplikace, která vlastní **pole, které zobrazuje**, nikoli podle aplikace, která vlastní zobrazení. Pole, které vaše aplikace přidá ke standardnímu objektu, má svůj sloupec odvozený pod vaší aplikací, a to v rámci zobrazení vlastněného Twenty.
+
+<Warning>
+  Systémová zobrazení a jejich sloupce jsou **vlastněna serverem**: vyhodnocujte jejich identifikátory pro účely odkazování, nikdy pro jejich deklaraci. `key` u
+  [`defineView()`](/l/cs/developers/extend/apps/layout/views) je zastaralý a
+  ignorovaný, takže manifestové zobrazení nikdy nemůže nárokovat klíč `INDEX` a server už zřizuje sloupec pro každé pole, které přidáte, takže deklarovat vlastní
+  `defineViewField()` pro stejné pole v systémovém zobrazení s tím bude v konfliktu.
+</Warning>
+
+## Standardní objekty Twenty
+
+U **standardního** objektu Twenty (Person, Company, Opportunity, …) nemusíte nic odvozovat: identifikátory jsou předpočítané konstanty, které můžete přímo importovat, a to jak pro pole, tak pro zobrazení.
+
+```ts
+import { STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS } from 'twenty-sdk/define';
+
+// STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.company.fields.createdAt.universalIdentifier
+// STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.person.fields.updatedAt.universalIdentifier
+// STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.person.views.allPeople.universalIdentifier
+```
+
+Použijte pomocné funkce uvedené výše v případě, kdy je objekt definován **vaší aplikací** pomocí [`defineObject()`](/l/cs/developers/extend/apps/data/objects) a žádná taková konstanta neexistuje.
+
+<Note>
+  `name` je **výchozí** pole, nikoli systémové pole. Má svůj vlastní natvrdo daný
+  univerzální identifikátor a neodvozuje se pomocí
+  `getFieldUniversalIdentifier`. U objektů, které definujete, odkazujte na pole
+  `name` pomocí identifikátoru, který jste mu dali v `defineObject()`.
+</Note>

packages/twenty-docs/l/cs/developers/extend/apps/data/timeline-activity-types.mdx

@@ -0,0 +1,184 @@
+---
+title: Typy aktivit na časové ose
+description: Definujte automatické události auditu a explicitní události aplikace, které se zobrazují na časových osách záznamů.
+icon: clock-rotate-left
+---
+
+Typ aktivity na časové ose definuje stabilní slovník pro událost zobrazenou na časové ose záznamu. Standardní objekty a objekty aplikace používají stejný kontrakt: typ má popisek a ikonu, může volitelně deklarovat, kdy je vyvolán, a může se volitelně vykreslovat prostřednictvím jedné z [front components](/l/cs/developers/extend/apps/layout/front-components) vaší aplikace.
+
+<Note>
+  Typy aktivit na časové ose jsou ve verzi beta a brzy přijdou ve Twenty 2.34. Rozhraní
+  API se může vyvíjet, zatímco se učíme z případů použití vývojářů aplikací.
+</Note>
+
+Vytvořte jej pomocí scaffolderu:
+
+```bash filename="Terminal"
+yarn twenty dev:add timelineActivityType
+```
+
+Nebo jej definujte přímo:
+
+```ts filename="src/timeline-activity-types/post-card-created.ts"
+import { defineTimelineActivityType } from 'twenty-sdk/define';
+
+import { POST_CARD_UNIVERSAL_IDENTIFIER } from '../objects/post-card.object';
+
+export default defineTimelineActivityType({
+  universalIdentifier: 'f4fa646c-6e11-4d8f-a6be-c3b7a2fc7500',
+  name: 'postCardCreated',
+  label: 'created a post card',
+  icon: 'IconMail',
+  emit: {
+    on: 'created',
+    objectUniversalIdentifier: POST_CARD_UNIVERSAL_IDENTIFIER,
+  },
+});
+```
+
+## Automatické a explicitní události
+
+Přidejte "emitovat", když by mělo dvacet automaticky vytvářet tento typ. `emit.on` podporuje `created`, `updated`, `deleted`, `restored`, `linked`, a `unlinked`, zatímco `emit.objectUniversalIdentifier` identifikuje zdrojový objekt. Pouze jeden efektivní typ dokáže zvládnout stejný emit klíč — `on`, objekt a volitelný prostřednictvím vztahu — v pracovním prostoru.
+
+Bez `emit.through je událost zapsána na vlastní časové ose zdrojového záznamu. Chcete-li ji rozdmýchat se souvisejícími záznamy, nastavte `emit.through . elationFieldUniversalIdentifier\` buď přímé mnoho-jedno-vztahy, nebo [jedno-mnoho-vztažení](/l/cs/developers/extend/apps/data/relations#junction-relations) na zdrojovém objektu. Vztahy s morfem se rozdmýchají každému členu jejich morfské skupiny, takže jediná deklarace se může zaměřit na několik typů objektů.
+
+Pro přímý vztah vytváří vytváření nebo obnovování zdrojového záznamu `linked`, protože jeho smazání produkuje `unlinked`, a opakováním vztahu vznikne `nespojený` na předchozí cíl plus `linked` na nový cíl. Další aktualizace zdroje nevytvářejí události odkazů. Jedná se o smlouvu používanou přílohami, jejichž cílem je přímý morfologický vztah.
+
+Pro vztah mezi dvěma uzly identifikuje vztah od objektu ke křižovatce k cíli. Vytváření nebo smazání křižovatky produkuje `linked` nebo `unlinked`. Repointing either side of the junction row also produkuje událost spojení; aktualizace nespřízněných přechodových polí nikoli.
+
+Události `linked` a `unlinked` vyžadují `emit.through`, protože jejich spouštěč je změnou konfigurované přímé nebo křižovatkové vztahy.
+
+Jedná se například o stejnou obecnou smlouvu používanou poznámkami, úkoly, zprávami a událostmi v kalendáři:
+
+```ts filename="src/timeline-activity-types/post-card-linked.ts"
+import { defineTimelineActivityType } from 'twenty-sdk/define';
+
+import { POST_CARD_RECIPIENTS_FIELD_UNIVERSAL_IDENTIFIER } from '../fields/post-card-recipients-on-post-card.field';
+import { POST_CARD_UNIVERSAL_IDENTIFIER } from '../objects/post-card.object';
+
+export default defineTimelineActivityType({
+  universalIdentifier: 'f4fa646c-6e11-4d8f-a6be-c3b7a2fc7502',
+  name: 'postCardLinked',
+  label: 'received a post card',
+  icon: 'IconMail',
+  emit: {
+    on: 'linked',
+    objectUniversalIdentifier: POST_CARD_UNIVERSAL_IDENTIFIER,
+    through: {
+      relationFieldUniversalIdentifier:
+        POST_CARD_RECIPIENTS_FIELD_UNIVERSAL_IDENTIFIER,
+    },
+  },
+});
+```
+
+"Aktualizováno" prostřednictvím události je ve výchozím nastavení vypnuto pro každou zdrojovou aktualizaci. Nastavte `emit.through.triggerFieldUniversalIdentifiers` pokud se změní pouze na vybraná zdrojová pole, měla by se zobrazit v cílovém časovém horizontu.
+
+Vypni `emit` pro explicitní doménu, kterou tvá logická funkce sama vytváří. Tím se zamezí vytvoření automatického řádku pro audit i výslovného řádku pro tutéž operaci.
+
+```ts filename="src/timeline-activity-types/post-card-sent.ts"
+import { defineTimelineActivityType } from 'twenty-sdk/define';
+
+export default defineTimelineActivityType({
+  universalIdentifier: 'f4fa646c-6e11-4d8f-a6be-c3b7a2fc7501',
+  name: 'postCardSent',
+  label: 'sent a post card',
+  icon: 'IconSend',
+});
+```
+
+Vytvořte explicitní události pomocí [`createTimelineActivity()`](/l/cs/developers/extend/apps/logic/logic-functions#create-a-timeline-activity). Kód aplikace používá stabilní univerzální identifikátory. Dvacet vyřeší ID metadat specifických pro instalaci.
+
+## Vlastní vykreslování
+
+Bez přední komponenty vykreslí dvacet nativní generický řádek z popisku typu, ikony a propojených objektů. To funguje pro standardní a vlastní objekty bez vykreslování konkrétního objektu.
+
+Pro vlastní detaily nastavte `frontComponentUniversalIdentifier` na přední komponentu vlastněnou stejnou aplikací:
+
+```ts
+export default defineTimelineActivityType({
+  universalIdentifier: 'f4fa646c-6e11-4d8f-a6be-c3b7a2fc7501',
+  name: 'postCardSent',
+  label: 'sent a post card',
+  icon: 'IconSend',
+  frontComponentUniversalIdentifier: '88c15ae2-5f87-4a6b-b48f-1974bbe62eb7',
+});
+```
+
+Rodičovská řada zůstává zkrachovalou prezentací. Dvacet připojuje přední díl až poté, co uživatel rozšíří tento řádek, zabraňuje tomu, aby se pískovací box a pracovník pro každou viditelnou událost. Uvnitř komponenty zavolejte `useTimelineActivityId()` z `dvacet sdk/front-component` a přečtěte si ID řádku a načtěte všechna data, která potřebujete. Vrátí `null` pokud je komponenta vykreslena mimo časový řádek.
+
+## Přepsání prezentace jiné aplikace
+
+Aplikace vlastní automatické časové osy pro své vlastní objekty. Chcete-li přizpůsobit událost na objektu vlastněném jinou aplikací, deklarujte existující typ výslovně pomocí `replacesTimelineActivityTypeUniversalIdentifier`:
+
+```ts
+export default defineTimelineActivityType({
+  universalIdentifier: 'f4fa646c-6e11-4d8f-a6be-c3b7a2fc7503',
+  name: 'companyCreatedWithDeploymentContext',
+  label: 'was created from a deployment',
+  emit: {
+    on: 'created',
+    objectUniversalIdentifier: COMPANY_UNIVERSAL_IDENTIFIER,
+  },
+  replacesTimelineActivityTypeUniversalIdentifier:
+    RECORD_CREATED_TIMELINE_ACTIVITY_TYPE_UNIVERSAL_IDENTIFIER,
+  frontComponentUniversalIdentifier: '88c15ae2-5f87-4a6b-b48f-1974bbe62eb7',
+});
+```
+
+Přepsání musí obsahovat `emit`, protože nahrazuje existující automatický slot emit namísto typu pouze pro explicitní. Uvedený typ musí patřit k aplikaci cílového objektu a popsat stejnou akci a cestu. Odstranění přepsání aplikace obnoví základní typ; odstranění základního typu zakáže přepsání.
+
+## Pracovní prostor přepíše a ztiší
+
+Správci pracovního prostoru mohou změnit prezentaci typu nebo ztlumit jeho automatické a explicitní události bez vytvoření aplikace. Použijte metadata API mutaci `updateTimelineActivityType` s ID specifického typu instalace:
+
+```graphql
+mutation CustomizeTimelineActivityType(
+  $id: UUID!
+  $label: String
+  $icon: String
+  $isActive: Boolean
+) {
+  updateTimelineActivityType(
+    input: { id: $id, label: $label, icon: $icon, isActive: $isActive }
+  ) {
+    id
+    label
+    icon
+    isActive
+  }
+}
+```
+
+`label` a `icon` jsou uloženy jako přepisy pracovního prostoru, takže pozdější aktualizace aplikace nepřepisují volby správce. Nastavte `isActive` na `false` pro zastavení automatických emisí a odmítnutí nových explicitních událostí tohoto typu. Stávající řádky zůstávají viditelné.
+
+Obnovit výchozí nastavení aplikace, včetně aktivního stavu:
+
+```graphql
+mutation ResetTimelineActivityType($id: UUID!) {
+  resetTimelineActivityType(id: $id) {
+    id
+    label
+    icon
+    isActive
+  }
+}
+```
+
+## Konfigurační pole
+
+| Pole                                              | Povinné   | Popis                                                                                   |
+| ------------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| `universalIdentifier`                             | Ano       | Stabilní UUID pro tento typ zařízení a modernizace                                      |
+| `name`                                            | Ano       | Programový název lokální pro aplikaci; musí být v rámci aplikace jedinečný              |
+| `label`                                           | Ano       | Uživatelsky orientovaný text akce používaný nativním přehrávačem                        |
+| `icon`                                            | Ne        | Dvacet jmen ikony zobrazených vedle události                                            |
+| `emit`                                            | Ne        | Automatické prohlášení o emisích; v případě typů pouze s výslovnou výjimkou             |
+| `emit.on`                                         | S emailem | Auditní opatření, která způsobí, že tento typ bude napsán                               |
+| `emit.objectUniversalIdentifier`                  | S emailem | Objekt, jehož záznamy vypouštějí tento typ                                              |
+| `emit.through.relationFieldUniversalIdentifier`   | Ne        | Vztah k přímému nebo rozvodnému vedení používanému k ventilaci příslušných časových řad |
+| `emit.through.triggerFieldUniversalIdentifiers`   | Ne        | Zdrojová pole, která mohou spustit `aktualizované` prostřednictvím události             |
+| `frontComponentUniversalIdentifier`               | Ne        | Čelní díl vlastněný App připojený při rozšíření řádku                                   |
+| `replacesTimelineActivityTypeUniversalIdentifier` | Ne        | Stávající typ emit nahrazen; vyžaduje `emit`                                            |
+
+Dvacet snímků sémantické identity a trvanlivé prezentace při vytvoření události. Historické řádky zachovávají svou původní akci a význam objektu. Zatímco je tento typ nainstalován, jeho aktuální přeložený popisek, ikona a hlavní komponenty vykreslují živě; po odinstalování udržuje záložní snímek řádek čitelný. Rozlišení používá univerzální identifikátor, takže prezentace také přežívá přeinstalování aplikace.