@mediacubeco/expo-template-fsd 1.2.0 → 2.0.0

package/.claude/rules/app-routing.mdc

@@ -1,12 +1,12 @@
 ---
-description: Thin Expo Router layer in src/app — layout/screen and delegation to ~screens
+description: Thin Expo Router layer in src/app — layout/screen and delegation to ~pages
 globs: src/app/**/*.tsx
 alwaysApply: false
 ---
 
 # `src/app` layer (Expo Router)
 
-Files under `src/app` only wire routes to implementation. Screen UI and business logic live in `~screens/*` (or other features), not in `app`.
+Files under `src/app` only wire routes to implementation. Screen UI and business logic live in `~pages/*` (or other features), not in `app`.
 
 ## `_layout.tsx`
 
@@ -16,9 +16,9 @@ Files under `src/app` only wire routes to implementation. Screen UI and business
 
 ## Route screen files (`index.tsx`, `[param].tsx`, named routes, etc.)
 
-- The main component is a function named **`screen`**; it only renders the root screen from `~screens/...` (import a single root screen component).
+- The main component is a function named **`screen`**; it only renders the root screen from `~pages/...` (import a single root screen component).
 - **Default**-export it (`export default screen` at the end of the file, same export rules).
-- Do not duplicate screen markup in the route file — only a thin wrapper around the `~screens` import.
+- Do not duplicate screen markup in the route file — only a thin wrapper around the `~pages` import.
 
 ## Exceptions
 
@@ -37,7 +37,7 @@ export default Layout
 
 ```tsx
 // route screen
-import { SomeFeatureScreen } from '~screens/some-feature'
+import { SomeFeatureScreen } from '~pages/some-feature'
 
 function Screen() {
   return <SomeFeatureScreen />

package/.claude/rules/mediacubeco-packages.mdc

@@ -0,0 +1,56 @@
+---
+description: Enforce use of @mediacubeco/* corporate packages over custom re-implementations
+alwaysApply: true
+---
+
+# Use @mediacubeco/\* corporate packages
+
+All utilities, helpers, hooks, and configs that exist in `@mediacubeco/*` packages **must** be imported from there. Do not duplicate or re-implement what is already provided.
+
+## Available packages
+
+To discover what each package exports, read its DTS index:
+
+- `@mediacubeco/base` — `dist/index.d.ts`
+  - subpaths: `/helpers`, `/services`, `/types`, `/utils`
+- `@mediacubeco/base-react-native` — `dist/index.d.ts`
+  - subpaths: `/helpers`, `/hooks`, `/utils`
+
+## Rules
+
+- Before writing any utility, helper, hook, or type — read the relevant package's DTS index and check if it already exists.
+- Always import via subpath, never from the package root:
+  - `@mediacubeco/base/utils` ✅ — `@mediacubeco/base` ❌
+  - `@mediacubeco/base-react-native/hooks` ✅ — `@mediacubeco/base-react-native` ❌
+- Never copy source from a `@mediacubeco/*` package into the app.
+- ESLint, Prettier, and TypeScript configs must extend the corresponding `@mediacubeco/*` config package — do not inline equivalent rules.
+- If something is missing from a `@mediacubeco/*` package, add it there first, then import it in the app.
+
+## Examples
+
+```typescript
+// ✅ GOOD — subpath import
+import { isNull } from '@mediacubeco/base/utils'
+
+// ❌ BAD — inline
+value === null
+
+// ❌ BAD — root import
+import { isNull } from '@mediacubeco/base'
+
+// ❌ BAD — reimplementing what already exists
+function isNull(value: unknown): value is null {
+  return value === null
+}
+```
+
+```typescript
+// ✅ GOOD — subpath import
+import { useKeyboard } from '@mediacubeco/base-react-native/hooks'
+
+// ❌ BAD — root import
+import { useKeyboard } from '@mediacubeco/base-react-native'
+
+// ❌ BAD — custom re-implementation
+function useKeyboard() { /* ... */ }
+```

package/.claude/settings.json

@@ -0,0 +1,11 @@
+{
+  "enabledPlugins": {
+    "gitlab@claude-plugins-official": true,
+
+    "superpowers@claude-plugins-official": true,
+
+    "expo@claude-plugins-official": true,
+    "code-review@claude-plugins-official": true,
+    "code-simplifier@claude-plugins-official": true
+  }
+}

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//Users/alkhimenok/Public/Programing/Work/kit/**)",
+      "Bash(npm view *)",
+      "Bash(npx expo *)",
+      "Bash(npx expo-doctor *)",
+      "Bash(pnpm install *)"
+    ]
+  }
+}

package/.claude/skills/code-style/SKILL.md

@@ -0,0 +1 @@
+TODO: fill

package/.claude/skills/generate-api-model/SKILL.md

@@ -1,98 +1,230 @@
 ---
 name: generate-api-model
 description: >-
-  Generates API resource types and entity classes following project conventions.
-  Use when creating new API models, entities, resources, or data types, or when
-  the user asks to add a new API model, entity, or resource type.
+  Generates API Resource types and Entity classes from a backend JSON response.
+  Use this skill whenever the user provides a backend JSON object or API schema
+  and wants TypeScript types generated from it, asks to "add a new API model",
+  "create an entity for...", "generate resource and entity", or wants to model
+  an API response. Also use when adding new domain types to the shared API
+  library (resources/ + entities/ folders).
 ---
 
 # Generate API Model
 
-## Overview
+## What this skill does
 
-For each **domain** object from the API, add:
+Take a **backend JSON response** (or API contract) and produce two TypeScript artifacts per domain object:
 
-- **Resource** — a TypeScript type describing the DTO as returned on the wire (JSON shape).
-- **Entity** — a class that wraps that resource and exposes **camelCase** getters for the UI and domain logic.
+1. **Resource** (`*Resource`) — a `type` that mirrors the **exact wire format** of the backend: field names are copied verbatim, including any snake_case, camelCase, kebab-case, UPPER_SNAKE_CASE, or PascalCase the backend uses.
+2. **Entity** (`*Entity`) — a `class` that maps every field to strict **camelCase** and applies project naming conventions for dates, arrays, and booleans.
 
-Do **not** generate resource/entity pairs for generic HTTP envelopes by default (paginated wrappers, transport-only error shapes, etc.). Add those only if the task explicitly asks for response-layer types.
+## Filesystem layout
 
-## Where things live
+```
+<api-lib>/
+├── resources/
+│   ├── common.ts        ← BaseResource shared type (see references/)
+│   ├── index.ts         ← barrel re-exporting all domains
+│   └── <domain>/
+│       ├── index.ts     ← barrel for this domain
+│       └── <domain>.ts  ← Resource type(s) for this domain
+└── entities/
+    ├── common.ts        ← BaseEntity<T> base class (see references/)
+    ├── index.ts         ← barrel re-exporting all domains
+    └── <domain>/
+        ├── index.ts     ← barrel for this domain
+        └── <domain>.ts  ← Entity class for this domain
+```
 
-Use the project’s shared API library: sibling trees **`resources`** (DTO types) and **`entities`** (classes). In this repo they sit under the same parent folder as `models`, `repositories`, etc.; domain folders are **kebab-case** (see workspace naming rules).
+Domain folder names are **kebab-case**. See `references/` for complete working examples.
 
-| Layer    | Typical layout                                                                             |
-| -------- | ------------------------------------------------------------------------------------------ |
-| Resource | `<api-lib>/resources/<domain>/<domain>.ts` plus `resources/common.ts` for shared fragments |
-| Entity   | `<api-lib>/entities/<domain>/<domain>.ts` plus `entities/common.ts` for the base class     |
+---
+
+## Step 1 — Identify domains
+
+From the backend JSON, identify independent domain objects. Exclude generic HTTP envelopes (pagination wrappers, status/error shapes) unless the user explicitly requests them.
+
+**If the user did not specify a domain name for the root object — ask before generating anything.** Never invent a domain name on your own. The root domain name determines all type names, filenames, and folder names, so it must be confirmed by the user.
+
+Every distinct nested object that carries its own data becomes its own `*Resource` + `*Entity` pair.
 
-Each `<domain>/` folder has an `index.ts` that re-exports its modules. After adding a domain, export it from the **barrel** `resources/index.ts` and `entities/index.ts` (same pattern as existing domains).
+**Where to place nested domain files:** if a nested object only appears inside one parent domain, put its files **in the parent's folder** (e.g., `brand/brand-translation.ts`, `post/post-comment.ts`, `user/user-settings.ts`). Create a separate top-level folder only when the object appears across multiple domains or is clearly a standalone concept (e.g., `stored-file` that could be attached to many entities).
 
-## Naming
+---
+
+## Step 2 — Resource types (wire format)
+
+**Rule: Resource field names must exactly match the backend.** Copy them verbatim — do not normalize, rename, or change casing.
 
-| Item            | Convention                                                                                                    |
-| --------------- | ------------------------------------------------------------------------------------------------------------- |
-| Folder / file   | kebab-case; primary domain module is `<domain>.ts`, shared cross-domain fragments use a name like `common.ts` |
-| Resource type   | `{Domain}Resource` (and `{Domain}{Aspect}Resource` for small unions or nested DTOs owned by that file)        |
-| Entity class    | `{Domain}Entity`                                                                                              |
-| Resource fields | **Match the wire format** — same spelling and casing as the API for each property                             |
-| Entity getters  | camelCase                                                                                                     |
+```typescript
+// Backend sends: { "first_name": "John", "UserAge": 30, "is-active": true }
+type UserResource = BaseResource & {
+  'first_name'?: string // snake_case preserved as-is
+  'UserAge'?: number // PascalCase preserved as-is
+  'is-active'?: boolean // hyphenated keys must be quoted
+}
+```
 
-Nested domain objects get their own `<nested-domain>/` with `*Resource` + `*Entity`, then referenced from the parent resource/entity.
+Additional rules:
 
-## Wire format (resources)
+- All fields are **optional** (`?`) by default, unless the contract guarantees the field is always present.
+- **Do not add `id`, `createdAt` / `updatedAt`, or `isPending`** to domain Resource types — these are already declared in `BaseResource` and inherited automatically.
+- Nested objects → their own `*Resource` type in a sibling file, referenced here.
+- Arrays of objects → `ChildResource[]`.
+- String enums → `export enum` in the same file as the resource that owns the field.
+- Import `BaseResource` from `../common` (or the resources barrel).
+
+---
 
-1. Take field names from the real JSON, OpenAPI schema, or agreed contract.
-2. Property names on `*Resource` must **match the API** for each field (whether snake_case, camelCase, or mixed).
-3. Do **not** normalize keys to a different convention “by habit” if the contract says otherwise.
-4. `BaseResource` (or equivalent shared type) should include only fields that are **actually shared** across many DTOs, usually as **optional** members. If some responses omit `id` or timestamps, keep those optional or omit them from the base and declare per-resource.
-5. A concrete `*Resource` may **intersect** with the base and add or refine fields (including refining `id` if the backend uses different scalar types per resource). Avoid types that claim keys the response never sends.
+## Step 3 — Entity classes (always camelCase)
 
-## Base types
+Every property in the Entity must be **camelCase**, regardless of the wire-format key.
 
-### Shared resource fragment (`resources/common.ts`)
+### Case conversion table
 
-Export a minimal **type** (e.g. `BaseResource`) for identifiers and audit columns **in the naming the backend uses** for those shared fields.
+| Wire format      | Wire key example  | Entity field    |
+| ---------------- | ----------------- | --------------- |
+| snake_case       | `created_at`      | `createdAt`     |
+| snake_case       | `first_name`      | `firstName`     |
+| snake_case       | `number_of_likes` | `numberOfLikes` |
+| kebab-case       | `user-name`       | `userName`      |
+| kebab-case       | `post-id`         | `postId`        |
+| UPPER_SNAKE_CASE | `USER_NAME`       | `userName`      |
+| UPPER_SNAKE_CASE | `POST_ID`         | `postId`        |
+| camelCase        | `firstName`       | `firstName`     |
+| PascalCase       | `FirstName`       | `firstName`     |
 
-### Base entity (`entities/common.ts`)
+**Algorithm:** split the wire key on `_`, `-`, spaces, or case-boundary transitions (uppercase after lowercase) → lowercase the first segment, capitalize the first letter of every subsequent segment → join.
 
-- Define a **generic** base class, e.g. `BaseEntity<Resource extends BaseResource>`, with a `protected` optional reference to the payload (commonly `resource`).
-- Constructor accepts that optional `Resource`.
-- Shared getters map from **the keys present on the shared resource fragment** to camelCase (e.g. wire `created_at` → getter `createdAt`), using optional chaining and sensible defaults only where the product expects them (e.g. dates, counts).
+### Entity naming conventions
 
-Subclasses: `export class {Domain}Entity extends BaseEntity<{Domain}Resource>` — rely on the generic parameter for typing `this.resource`; **do not** duplicate the pattern from older guides that reassign a separate typed field after `super` unless this codebase already does that elsewhere.
+After converting to camelCase, apply these semantic rules:
 
-## Entity subclasses
+#### Dates → must end in `at`
 
-1. Extend `BaseEntity<{Domain}Resource>`.
-2. Add getters only for fields that exist on that resource type (plus inherited shared getters).
-3. **Nested entities:** return `new ChildEntity(this.resource?.someKey)` (or map arrays with the same idea).
-4. **Primitives:** optional chaining; use `??` with defaults where the UI needs a non-optional value (counts → `0`, flags → `false`, strings → `''` when appropriate).
+Any field that represents a point in time must end with `at`.
 
-Getter names are always camelCase; the **property access** inside uses the actual keys declared on `*Resource`.
+```
+created_at    → createdAt     ✓
+updated_at    → updatedAt     ✓
+publish_date  → publishedAt   ✓  (rename: "date" → "at")
+expiry        → expiredAt     ✓  (rename: add "at" suffix)
+birth_date    → birthAt       ✓
+```
 
-## Resource module rules
+#### Arrays → must end in `list`
 
-1. Import the shared fragment from the resources `common` module (relative path depends on depth).
-2. Export `export type {Domain}Resource = BaseResource & { ... }`.
-3. Nested object → separate `*Resource` in its own module; arrays → `ChildResource[]`.
-4. String unions / enums → `export type` aliases in the same file as the resource that owns the field.
+All array properties in Entity end in `list`. Strip a trailing plural `s` (when it makes the base form a clean word) before appending `List`.
 
-## Imports between layers
+Resource keeps the backend wire name; Entity renames to `*List`.
 
-Entities depend on resource types (import from the resources tree or its barrel). Keep dependency direction **resources → nothing in entities**; **entities → resources** only.
+```
+// Resource field (wire name)         Entity field (camelCase + list)
+comments: PostCommentResource[]   →   commentList: PostCommentEntity[]
+tags: string[]                    →   tagList: string[]
+user_posts: PostResource[]        →   userPostList: PostEntity[]
+items: ItemResource[]             →   itemList: ItemEntity[]
+```
+
+If the backend already uses a `list`-style name (e.g., `comment_list`), the Entity field is simply the camelCase conversion: `commentList`.
+
+#### Booleans → should start with `is`, `has`, `did`, `can`, `should`, `was`, `will`
+
+```
+is_email_verified  → isEmailVerified  ✓
+verified           → isVerified       ✓  (add prefix when the boolean nature is clear)
+email_confirmed    → didConfirmEmail  ✓
+can_edit           → canEdit          ✓
+has_access         → hasAccess        ✓
+```
+
+### Entity constructor pattern
+
+**Do not re-declare or set `id`, `createdAt`, `updatedAt` in domain entities** — `BaseEntity` already handles them via `super(resource, context)`. Only add fields that are specific to this domain.
+
+See `references/entities/common.ts` for the full `BaseEntity<T>` implementation and `references/entities/post/post.ts` for a complete domain example (with nested entity, array `→ List`, and cross-domain reference).
+
+Default values by type:
+| Type | Default |
+|------------------|-----------------------|
+| `string` | `''` |
+| `number` | `0` |
+| `boolean` | `false` |
+| `Date` | `new Date()` |
+| nested Entity | `new ChildEntity(resource?.field, this)` |
+| array | `[]` |
+
+---
 
-## Workflow
+## Step 4 — Barrel index files
 
-1. **Scope** — list domain DTOs only; exclude wrappers unless requested.
-2. **Wire names** — copy property names from the contract into `*Resource`.
-3. **Align the shared resource fragment** — smallest common optional shape; refine per domain where needed.
-4. **Resources first, bottom-up** — leaf nested DTOs, then parents.
-5. **Entities** — one class per resource; generic `BaseEntity<{Domain}Resource>`; nest `new …Entity(…)`.
-6. **Barrels** — `index.ts` per domain folder and parent `resources/index.ts` / `entities/index.ts`.
+Each `<domain>/` folder must have an `index.ts` re-exporting its modules. After adding a new domain, update the parent barrels too.
+
+See `references/resources/post/index.ts`, `references/entities/post/index.ts`, and `references/resources/index.ts` for examples.
+
+---
+
+## Import conventions
+
+```typescript
+// Inside a Resource file:
+import { BaseResource } from '../common'
+import { ChildResource } from './child-domain'
+
+// Inside an Entity file:
+import { BaseResource, DomainResource } from '../../resources'
+import { BaseEntity } from '../common'
+import { ChildEntity } from '../child-domain'
+```
+
+Dependency direction is **entities → resources only**. Resources never import from entities.
+
+---
 
 ## Export style
 
-- Resource types: `export type { … }`
-- Entity classes: `export class …`
-- Index files: `export * from './<module>'`
+```typescript
+// Resource files:
+export type { DomainResource }
+export { DomainStatusEnum } // enums use a regular (value) export
+
+// Entity files:
+export { DomainEntity }
+
+// Index files:
+export * from './domain'
+```
+
+---
+
+## Checklist before finishing
+
+- [ ] Every Resource field name matches the backend wire format exactly (no renaming)
+- [ ] Every Entity property is camelCase
+- [ ] All date fields in Entity end in `at`
+- [ ] All array fields in Entity end in `list`
+- [ ] All boolean fields in Entity start with `is` / `has` / `did` / `can` / `should` / `was` / `will`
+- [ ] Nested objects have their own `*Resource` + `*Entity` files
+- [ ] Each domain folder has an `index.ts` barrel
+- [ ] Parent `resources/index.ts` and `entities/index.ts` updated
+
+---
+
+## Reference examples
+
+Read these files to understand the complete, working implementation:
+
+| File                                         | What it shows                                                                 |
+| -------------------------------------------- | ----------------------------------------------------------------------------- |
+| `references/resources/common.ts`             | `BaseResource` type — `id`, `created_at`, `updated_at`, `is_pending`          |
+| `references/entities/common.ts`              | `BaseEntity<T>` — `generateIdFactory`, `isPending` getter, `super()` contract |
+| `references/resources/post/post.ts`          | Resource with snake_case fields, nested types, cross-domain ref               |
+| `references/entities/post/post.ts`           | Entity with camelCase, `commentList`, `numberOfLikes`, nested `UserEntity`    |
+| `references/resources/post/post-comment.ts`  | Minimal nested Resource inside a parent domain folder                         |
+| `references/entities/post/post-comment.ts`   | Minimal nested Entity inside a parent domain folder                           |
+| `references/resources/user/user.ts`          | Multi-file domain Resource with two nested sub-resources                      |
+| `references/entities/user/user.ts`           | Multi-file domain Entity with two nested sub-entities                         |
+| `references/resources/user/user-settings.ts` | Leaf Resource (no further nesting)                                            |
+| `references/entities/user/user-settings.ts`  | Leaf Entity (no further nesting)                                              |
+| `references/resources/post/index.ts`         | Domain barrel — re-exports all files in the folder                            |
+| `references/resources/index.ts`              | Root barrel — re-exports all domains + common                                 |

package/.claude/skills/generate-api-model/references/entities/common.ts

@@ -0,0 +1,28 @@
+import { generateIdFactory } from '@mediacontent/base/utils'
+import { type BaseResource } from '../resources'
+
+const generateId = generateIdFactory()
+
+class BaseEntity<Resource extends BaseResource> {
+  protected readonly resource?: Resource
+  protected readonly context?: BaseResource
+
+  id: string
+  createdAt: Date
+  updatedAt: Date
+
+  constructor(resource?: Resource, context?: BaseResource) {
+    this.resource = resource
+    this.context = context
+
+    this.id = resource?.id ?? generateId()
+    this.createdAt = resource?.created_at ?? new Date()
+    this.updatedAt = resource?.updated_at ?? new Date()
+  }
+
+  get isPending() {
+    return this.resource?.is_pending ?? this.context?.is_pending ?? false
+  }
+}
+
+export { BaseEntity }

package/.claude/skills/generate-api-model/references/entities/index.ts

@@ -0,0 +1,4 @@
+export * from './common'
+
+export * from './post'
+export * from './user'

package/.claude/skills/generate-api-model/references/entities/post/index.ts

@@ -0,0 +1,2 @@
+export * from './post'
+export * from './post-comment'

package/.claude/skills/generate-api-model/references/entities/post/post-comment.ts

@@ -0,0 +1,16 @@
+import { type BaseResource, type PostCommentResource } from '../../resources'
+import { BaseEntity } from '../common'
+
+class PostCommentEntity extends BaseEntity<PostCommentResource> {
+  description: string
+  numberOfLikes: number
+
+  constructor(resource?: PostCommentResource, context?: BaseResource) {
+    super(resource, context)
+
+    this.description = resource?.description ?? '-'
+    this.numberOfLikes = resource?.number_of_likes ?? 0
+  }
+}
+
+export { PostCommentEntity }

package/.claude/skills/generate-api-model/references/entities/post/post.ts

@@ -0,0 +1,27 @@
+import { type BaseResource, type PostResource } from '../../resources'
+import { BaseEntity } from '../common'
+import { UserEntity } from '../user'
+import { PostCommentEntity } from './post-comment'
+
+class PostEntity extends BaseEntity<PostResource> {
+  title: string
+  description: string
+  numberOfLikes: number
+  numberOfComments: number
+  user: UserEntity
+  commentList: PostCommentEntity[]
+
+  constructor(resource?: PostResource, context?: BaseResource) {
+    super(resource, context)
+
+    this.title = resource?.title ?? ''
+    this.description = resource?.description ?? ''
+    this.numberOfLikes = resource?.number_of_likes ?? 0
+    this.numberOfComments = resource?.number_of_comments ?? 0
+    this.user = new UserEntity(resource?.user, this)
+    this.commentList =
+      resource?.comments?.map((comment) => new PostCommentEntity(comment, this)) ?? []
+  }
+}
+
+export { PostEntity }

package/.claude/skills/generate-api-model/references/entities/user/index.ts

@@ -0,0 +1,3 @@
+export * from './user'
+export * from './user-settings'
+export * from './user-verification'

package/.claude/skills/generate-api-model/references/entities/user/user-settings.ts

@@ -0,0 +1,16 @@
+import { type BaseResource, type UserSettingsResource } from '../../resources'
+import { BaseEntity } from '../common'
+
+class UserSettingsEntity extends BaseEntity<UserSettingsResource> {
+  language: string
+  theme: string
+
+  constructor(resource?: UserSettingsResource, context?: BaseResource) {
+    super(resource, context)
+
+    this.language = resource?.language ?? 'en'
+    this.theme = resource?.theme ?? 'system'
+  }
+}
+
+export { UserSettingsEntity }

package/.claude/skills/generate-api-model/references/entities/user/user-verification.ts

@@ -0,0 +1,22 @@
+import {
+  type BaseResource,
+  type UserVerificationResource,
+  UserVerificationStatus,
+} from '../../resources'
+import { BaseEntity } from '../common'
+
+class UserVerificationEntity extends BaseEntity<UserVerificationResource> {
+  isEmailVerified: boolean
+  isPhoneVerified: boolean
+  status: UserVerificationStatus
+
+  constructor(resource?: UserVerificationResource, context?: BaseResource) {
+    super(resource, context)
+
+    this.isEmailVerified = resource?.is_email_verified ?? false
+    this.isPhoneVerified = resource?.is_phone_verified ?? false
+    this.status = resource?.status ?? UserVerificationStatus.Pending
+  }
+}
+
+export { UserVerificationEntity }

package/.claude/skills/generate-api-model/references/entities/user/user.ts

@@ -0,0 +1,26 @@
+import { type BaseResource, type UserResource } from '../../resources'
+import { BaseEntity } from '../common'
+import { UserSettingsEntity } from './user-settings'
+import { UserVerificationEntity } from './user-verification'
+
+class UserEntity extends BaseEntity<UserResource> {
+  firstName: string
+  lastName: string
+  fullName: string
+  avatar: string
+  verification: UserVerificationEntity
+  settings: UserSettingsEntity
+
+  constructor(resource?: UserResource, context?: BaseResource) {
+    super(resource, context)
+
+    this.firstName = resource?.first_name ?? 'UNKNOWN'
+    this.lastName = resource?.last_name ?? 'UNKNOWN'
+    this.fullName = `${resource?.first_name} ${resource?.last_name}`.trim() ?? 'UNKNOWN'
+    this.avatar = resource?.avatar ?? ''
+    this.verification = new UserVerificationEntity(resource?.verification, this)
+    this.settings = new UserSettingsEntity(resource?.settings, this)
+  }
+}
+
+export { UserEntity }

package/.claude/skills/generate-api-model/references/resources/common.ts

@@ -0,0 +1,8 @@
+type BaseResource = {
+  id?: string
+  created_at?: Date
+  updated_at?: Date
+  is_pending?: boolean
+}
+
+export type { BaseResource }

package/.claude/skills/generate-api-model/references/resources/index.ts

@@ -0,0 +1,4 @@
+export * from './common'
+
+export * from './user'
+export * from './post'

package/.claude/skills/generate-api-model/references/resources/post/index.ts

@@ -0,0 +1,2 @@
+export * from './post'
+export * from './post-comment'

package/.claude/skills/generate-api-model/references/resources/post/post-comment.ts

@@ -0,0 +1,8 @@
+import { type BaseResource } from '../common'
+
+type PostCommentResource = BaseResource & {
+  description: string
+  number_of_likes: number
+}
+
+export type { PostCommentResource }

package/.claude/skills/generate-api-model/references/resources/post/post.ts

@@ -0,0 +1,14 @@
+import { type BaseResource } from '../common'
+import { type UserResource } from '../user'
+import { type PostCommentResource } from './post-comment'
+
+type PostResource = BaseResource & {
+  title?: string
+  description?: string
+  number_of_likes?: number
+  number_of_comments?: number
+  user?: UserResource
+  comments?: PostCommentResource[]
+}
+
+export type { PostResource }

package/.claude/skills/generate-api-model/references/resources/user/index.ts

@@ -0,0 +1,3 @@
+export * from './user'
+export * from './user-settings'
+export * from './user-verification'

package/.claude/skills/generate-api-model/references/resources/user/user-settings.ts

@@ -0,0 +1,8 @@
+import { type BaseResource } from '../common'
+
+type UserSettingsResource = BaseResource & {
+  language?: string
+  theme?: string
+}
+
+export type { UserSettingsResource }