# Business Logic — KKW01031SF02DBean.typeModelData() [164 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `eo.web.webview.KKW01031SF.KKW01031SF02DBean` |
| Layer | Web Bean / View Data (Controller-adjacent) |
| Module | `KKW01031SF` (Package: `eo.web.webview.KKW01031SF`) |

## 1. Role

### KKW01031SF02DBean.typeModelData()

The `typeModelData` method is a **type-introspection router** that maps business-facing field names and sub-keys to their corresponding Java `Class<?>` types for use in a dynamic data-binding framework. It enables the front-end screen layer to query what type a given data model field expects — critical for rendering form controls (text inputs, checkboxes, etc.) dynamically without hardcoding field types in the view layer.

The method handles **13 distinct business fields**, each representing a UI data element related to telecommunications service campaigns and contract management. Fields include record counts, contract details, campaign metadata, status codes, type codes, and date ranges. Each field is queried with a sub-key that describes the property aspect being requested — `"value"` (the data type), `"enable"` (a boolean toggle), or `"state"` (a status string).

This method implements the **routing/dispatch pattern**: it branches on the `key` parameter, then further dispatches on the `subkey` parameter, returning the appropriate `Class<?>` object. It implements part of the `X33VDataTypeBeanInterface` contract (or its parent framework), which allows the X33S data-binding framework to build type maps for dynamic form rendering.

It is a **shared utility** called by many screens across the FUW (Web View) module family — not a screen entry point, but a metadata provider used during screen initialization to determine field types for dynamic UI construction. It performs **no database operations, no business logic mutations, and no service calls** — it is purely a read-only type-mapping lookup.

Conditional branches cover:
- **Null guard**: returns `null` immediately if either `key` or `subkey` is `null`.
- **13 field branches**: each maps `key` to a specific business field (e.g., "番号 / 件数" = Record Count, "契約種別" = Contract Type). Within each, `subkey` of `"value"` returns `String.class`, `"enable"` returns `Boolean.class` (where applicable), `"state"` returns `String.class`.
- **Default fallback**: if no `key` matches any of the 13 fields, returns `null`.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["typeModelData key, subkey"])
    NC{key or subkey null?}
    NS["Parse key for slash separator"]

    K1{"key = 番号 / 件数"}
    K2{"key = 番号"}
    K3{"key = 契約種別"}
    K4{"key = 更新年月日時更新前"}
    K5{"key = キャンペーン名称"}
    K6{"key = ステータス"}
    K7{"key = ステータス名称"}
    K8{"key = タイプコード"}
    K9{"key = タイプコード名称"}
    K10{"key = 即時適用フラグ"}
    K11{"key = 即時適用フラグ名称"}
    K12{"key = 開始年月日"}
    K13{"key = 終了年月日"}

    NA["Return null - no match"]
    RD1["return String.class"]
    RD2["return Boolean.class"]
    RD3["return null - no match"]

    START --> NC
    NC -- Yes --> NA
    NC -- No --> NS
    NS --> K1

    K1 -- Yes --> S1V{subkey value?}
    S1V -- Yes --> RD1
    S1V -- No --> S1E{subkey enable?}
    S1E -- Yes --> RD2
    S1E -- No --> S1S{subkey state?}
    S1S -- Yes --> RD1
    S1S -- No --> K2

    K1 -- No --> K2

    K2 -- Yes --> S2V{subkey value?}
    S2V -- Yes --> RD1
    S2V -- No --> S2S{subkey state?}
    S2S -- Yes --> RD1
    S2S -- No --> K3

    K2 -- No --> K3

    K3 -- Yes --> S3V{subkey value?}
    S3V -- Yes --> RD1
    S3V -- No --> S3S{subkey state?}
    S3S -- Yes --> RD1
    S3S -- No --> K4

    K3 -- No --> K4

    K4 -- Yes --> S4V{subkey value?}
    S4V -- Yes --> RD1
    S4V -- No --> S4S{subkey state?}
    S4S -- Yes --> RD1
    S4S -- No --> K5

    K4 -- No --> K5

    K5 -- Yes --> S5V{subkey value?}
    S5V -- Yes --> RD1
    S5V -- No --> S5E{subkey enable?}
    S5E -- Yes --> RD2
    S5E -- No --> S5S{subkey state?}
    S5S -- Yes --> RD1
    S5S -- No --> K6

    K5 -- No --> K6

    K6 -- Yes --> S6V{subkey value?}
    S6V -- Yes --> RD1
    S6V -- No --> S6S{subkey state?}
    S6S -- Yes --> RD1
    S6S -- No --> K7

    K6 -- No --> K7

    K7 -- Yes --> S7V{subkey value?}
    S7V -- Yes --> RD1
    S7V -- No --> S7E{subkey enable?}
    S7E -- Yes --> RD2
    S7E -- No --> S7S{subkey state?}
    S7S -- Yes --> RD1
    S7S -- No --> K8

    K7 -- No --> K8

    K8 -- Yes --> S8V{subkey value?}
    S8V -- Yes --> RD1
    S8V -- No --> S8S{subkey state?}
    S8S -- Yes --> RD1
    S8S -- No --> K9

    K8 -- No --> K9

    K9 -- Yes --> S9V{subkey value?}
    S9V -- Yes --> RD1
    S9V -- No --> S9E{subkey enable?}
    S9E -- Yes --> RD2
    S9E -- No --> S9S{subkey state?}
    S9S -- Yes --> RD1
    S9S -- No --> K10

    K9 -- No --> K10

    K10 -- Yes --> S10V{subkey value?}
    S10V -- Yes --> RD1
    S10V -- No --> S10S{subkey state?}
    S10S -- Yes --> RD1
    S10S -- No --> K11

    K10 -- No --> K11

    K11 -- Yes --> S11V{subkey value?}
    S11V -- Yes --> RD1
    S11V -- No --> S11E{subkey enable?}
    S11E -- Yes --> RD2
    S11E -- No --> S11S{subkey state?}
    S11S -- Yes --> RD1
    S11S -- No --> K12

    K11 -- No --> K12

    K12 -- Yes --> S12V{subkey value?}
    S12V -- Yes --> RD1
    S12V -- No --> S12E{subkey enable?}
    S12E -- Yes --> RD2
    S12E -- No --> S12S{subkey state?}
    S12S -- Yes --> RD1
    S12S -- No --> K13

    K12 -- No --> K13

    K13 -- Yes --> S13V{subkey value?}
    S13V -- Yes --> RD1
    S13V -- No --> S13E{subkey enable?}
    S13E -- Yes --> RD2
    S13E -- No --> S13S{subkey state?}
    S13S -- Yes --> RD1
    S13S -- No --> NA

    K13 -- No --> NA

    RD1 --> END_N(["Return / Next"])
    RD2 --> END_N
    NA --> END_N
```

**Processing Flow Description:**

1. **Null Guard** (L875-L878): If `key` or `subkey` is `null`, immediately return `null`.
2. **Separator Detection** (L880): Search for a `/` (slash) in `key` using `indexOf`. The result is stored locally but not used for any conditional branching — it appears to be a vestigial check or future extension hook.
3. **Field Dispatch Chain** (L883–L1032): A cascading `if/else-if` chain evaluates 13 business field keys. Each field has a consistent subkey pattern:
   - `"value"` (case-insensitive) → `String.class` — the primary data type.
   - `"enable"` (case-insensitive) → `Boolean.class` — whether the field is enabled/toggleable (only on 6 of 13 fields).
   - `"state"` (case-insensitive) → `String.class` — the UI state/status type.
4. **Fallback** (L1034): If no field matches, return `null`.

**Fields that support `"enable"` subkey:**
- "番号 / 件数" (L886)
- "キャンペーン名称" (L918)
- "ステータス名称" (L950)
- "タイプコード名称" (L982)
- "即時適用フラグ名称" (L1014)
- "開始年月日" (L1026)
- "終了年月日" (L1032)

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `key` | `String` | The business field name that identifies which data model element's type is being queried. Represents a human-readable label displayed in the UI (e.g., "契約種別" = Contract Type, "キャンペーン名称" = Campaign Name). Determines which of the 13 field branches the method follows. Case-sensitive string comparison. |
| 2 | `subkey` | `String` | The property aspect within a field whose type is being queried. Three recognized values (case-insensitive): `"value"` returns the primary data type (always `String.class`), `"enable"` returns whether the field has an enable/disable toggle (`Boolean.class` on 7 fields), `"state"` returns the UI state type (always `String.class`). |

**No instance fields or external state** are read by this method. It is a pure function — its output depends solely on its two parameters.

## 4. CRUD Operations / Called Services

This method performs **zero CRUD operations**. It is a pure type-mapping utility with no method calls to services, CBS components, or data access layers. It contains no database queries, no entity updates, and no external calls.

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| *(none)* | — | — | — | `typeModelData` is a pure function with no service calls, database access, or side effects. It returns `Class<?>` objects based on field name routing. |

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Screen:KKW01031SF | `KKW01031SFBean.getTypeModelData` -> `KKW01031SF02DBean.typeModelData` | *(none — pure function)* |
| 2 | Screen:FUW00901SF | `FUW00901SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 3 | Screen:FUW00912SF | `FUW00912SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 4 | Screen:FUW00912SF | `FUW00912SF01DBean.typeModelData(key, subkey)` -> `X33VDataTypeStringBean.typeModelData(subkey)` (delegates) | *(none — pure function)* |
| 5 | Screen:FUW00919SF | `FUW00919SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 6 | Screen:FUW00926SF | `FUW00926SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 7 | Screen:FUW00927SF | `FUW00927SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 8 | Screen:FUW00931SF | `FUW00931SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 9 | Screen:FUW00959SF | `FUW00959SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 10 | Screen:FUW00964SF | `FUW00964SFBean.typeModelData(gamenId, key, subkey)` -> `typeModelData(key, subkey)` (overload) | *(none — pure function)* |
| 11 | Screen:FUW00901SF | `FUW00901SF01DBean.typeModelData(key, subkey)` -> *(own implementation)* | *(none — pure function)* |
| 12 | Screen:FUW00919SF | `FUW00919SF01DBean.typeModelData(key, subkey)` -> *(own implementation)* | *(none — pure function)* |
| 13 | Screen:FUW00926SF | `FUW00926SF01DBean.typeModelData(key, subkey)` -> *(own implementation)* | *(none — pure function)* |
| 14 | Screen:FUW00926SF | `FUW00926SF02DBean.typeModelData(key, subkey)` -> *(own implementation)* | *(none — pure function)* |
| 15 | Screen:FUW00926SF | `FUW00926SF03DBean.typeModelData(key, subkey)` -> *(own implementation)* | *(none — pure function)* |

**Caller Context:** The FUW-series screens (FUW00901SF through FUW00964SF) call their own `typeModelData` methods to determine field types during dynamic screen rendering. These screens share a common X33S framework pattern where `typeModelData(String, String)` is invoked by the framework's data-binding engine to construct typed form elements from model definitions. The KKW01031SF screen family uses this method to support campaign-related data display fields.

## 6. Per-Branch Detail Blocks

**Block 1** — IF (null guard) `(key == null || subkey == null)` (L875)

> Null guard: if either parameter is null, return null immediately. This prevents downstream NPEs and is the first line of defense.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return null;` // key,subkey that are null, return null (key,subkey ga null no baai, null o kaesu) |

---

**Block 2** — SET (separator detection) (L880)

> Searches for the slash (`/`) separator in the key. The result is stored but not used for branching — potentially a vestigial hook or future extension point.

| # | Type | Code |
|---|------|------|
| 1 | SET | `int separaterPoint = key.indexOf("/");` // search for slash separator (separatapo) |

---

**Block 3** — IF/ELSE-IF Chain: Field Dispatch — Field 1 "番号 / 件数" (Record Count) (L883)

> Data type: String field "Record Count" (Item ID: no_cnt). Supports subkeys: value, enable, state.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("番号 / 件数")` // data type String item "Record Count" (Item ID: no_cnt) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L885) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("enable")` (L888) |
| 3.1 | RETURN | `return Boolean.class;` |
| 4 | ELSE-IF | `subkey.equalsIgnoreCase("state")` // subkey is "state", return status (subkey ga "state" no baai, status o kaesu) (L891) |
| 4.1 | RETURN | `return String.class;` |

---

**Block 4** — IF/ELSE-IF: Field 2 "番号" (Record No.) (L896)

> Data type: String field "Record Number" (Item ID: no). Supports subkeys: value, state. Note: does NOT support `"enable"`.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("番号")` // data type String item "Record Number" (Item ID: no) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L897) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("state")` // subkey is "state", return status (subkey ga "state" no baai, status o kaesu) (L901) |
| 3.1 | RETURN | `return String.class;` |

---

**Block 5** — IF/ELSE-IF: Field 3 "契約種別" (Contract Type) (L906)

> Data type: String field "Contract Type" (Item ID: kei_kind). Supports subkeys: value, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("契約種別")` // data type String item "Contract Type" (Item ID: kei_kind) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L907) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L910) |
| 3.1 | RETURN | `return String.class;` |

---

**Block 6** — IF/ELSE-IF: Field 4 "更新年月日時更新前" (Pre-Update Date/Time) (L916)

> Data type: String field "Pre-Update Date/Time" (Item ID: upd_dtm_bf). Supports subkeys: value, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("更新年月日時更新前")` // data type String item "Pre-Update Date/Time" (Item ID: upd_dtm_bf) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L917) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L920) |
| 3.1 | RETURN | `return String.class;` |

---

**Block 7** — IF/ELSE-IF: Field 5 "キャンペーン名称" (Campaign Name) (L926)

> Data type: String field "Campaign Name" (Item ID: campaign_nm). Supports subkeys: value, enable, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("キャンペーン名称")` // data type String item "Campaign Name" (Item ID: campaign_nm) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L927) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("enable")` (L930) |
| 3.1 | RETURN | `return Boolean.class;` |
| 4 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L933) |
| 4.1 | RETURN | `return String.class;` |

---

**Block 8** — IF/ELSE-IF: Field 6 "ステータス" (Status) (L939)

> Data type: String field "Status" (Item ID: stat). Supports subkeys: value, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("ステータス")` // data type String item "Status" (Item ID: stat) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L940) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L943) |
| 3.1 | RETURN | `return String.class;` |

---

**Block 9** — IF/ELSE-IF: Field 7 "ステータス名称" (Status Name) (L949)

> Data type: String field "Status Name" (Item ID: stat_nm). Supports subkeys: value, enable, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("ステータス名称")` // data type String item "Status Name" (Item ID: stat_nm) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L950) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("enable")` (L953) |
| 3.1 | RETURN | `return Boolean.class;` |
| 4 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L956) |
| 4.1 | RETURN | `return String.class;` |

---

**Block 10** — IF/ELSE-IF: Field 8 "タイプコード" (Type Code) (L962)

> Data type: String field "Type Code" (Item ID: type_cd). Supports subkeys: value, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("タイプコード")` // data type String item "Type Code" (Item ID: type_cd) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L963) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L966) |
| 3.1 | RETURN | `return String.class;` |

---

**Block 11** — IF/ELSE-IF: Field 9 "タイプコード名称" (Type Code Name) (L972)

> Data type: String field "Type Code Name" (Item ID: type_cd_nm). Supports subkeys: value, enable, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("タイプコード名称")` // data type String item "Type Code Name" (Item ID: type_cd_nm) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L973) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("enable")` (L976) |
| 3.1 | RETURN | `return Boolean.class;` |
| 4 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L979) |
| 4.1 | RETURN | `return String.class;` |

---

**Block 12** — IF/ELSE-IF: Field 10 "即時適用フラグ" (Immediate Apply Flag) (L985)

> Data type: String field "Immediate Apply Flag" (Item ID: aply_jun). Supports subkeys: value, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("即時適用フラグ")` // data type String item "Immediate Apply Flag" (Item ID: aply_jun) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L986) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L989) |
| 3.1 | RETURN | `return String.class;` |

---

**Block 13** — IF/ELSE-IF: Field 11 "即時適用フラグ名称" (Immediate Apply Flag Name) (L995)

> Data type: String field "Immediate Apply Flag Name" (Item ID: aply_jun_nm). Supports subkeys: value, enable, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("即時適用フラグ名称")` // data type String item "Immediate Apply Flag Name" (Item ID: aply_jun_nm) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L996) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("enable")` (L999) |
| 3.1 | RETURN | `return Boolean.class;` |
| 4 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L1002) |
| 4.1 | RETURN | `return String.class;` |

---

**Block 14** — IF/ELSE-IF: Field 12 "開始年月日" (Start Date) (L1008)

> Data type: String field "Start Date/Year-Month-Day" (Item ID: staymd). Supports subkeys: value, enable, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("開始年月日")` // data type String item "Start Date" (Item ID: staymd) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L1009) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("enable")` (L1012) |
| 3.1 | RETURN | `return Boolean.class;` |
| 4 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L1015) |
| 4.1 | RETURN | `return String.class;` |

---

**Block 15** — IF/ELSE-IF: Field 13 "終了年月日" (End Date) (L1021)

> Data type: String field "End Date/Year-Month-Day" (Item ID: endymd). Supports subkeys: value, enable, state.

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("終了年月日")` // data type String item "End Date" (Item ID: endymd) |
| 2 | IF | `subkey.equalsIgnoreCase("value")` (L1022) |
| 2.1 | RETURN | `return String.class;` |
| 3 | ELSE-IF | `subkey.equalsIgnoreCase("enable")` (L1025) |
| 3.1 | RETURN | `return Boolean.class;` |
| 4 | ELSE-IF | `subkey.equalsIgnoreCase("state")` (L1028) |
| 4.1 | RETURN | `return String.class;` |

---

**Block 16** — RETURN (default fallback) (L1034)

> No matching property exists; return null. (条件に一致するプロパティが存在しない場合は、null を返す。)

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return null;` // No matching property found, return null |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `no_cnt` | Field | Record count — the number of items/documents (件数). Used in the field "番号 / 件数" (Number / Count). |
| `no` | Field | Record number — an item's sequence or identifier (番号). |
| `kei_kind` | Field | Contract type — the category of service contract (契約種別). |
| `upd_dtm_bf` | Field | Pre-update date/time — timestamp before modification (更新年月日時更新前). |
| `campaign_nm` | Field | Campaign name — marketing campaign identifier (キャンペーン名称). |
| `stat` | Field | Status — the current state code (ステータス). |
| `stat_nm` | Field | Status name — human-readable status label (ステータス名称). |
| `type_cd` | Field | Type code — a classification code (タイプコード). |
| `type_cd_nm` | Field | Type code name — human-readable label for the type code (タイプコード名称). |
| `aply_jun` | Field | Immediate apply flag — whether changes apply instantly (即時適用フラグ). |
| `aply_jun_nm` | Field | Immediate apply flag name — label for the instant apply flag (即時適用フラグ名称). |
| `staymd` | Field | Start date — year/month/day the service begins (開始年月日). |
| `endymd` | Field | End date — year/month/day the service terminates (終了年月日). |
| `X33SException` | Acronym | X33S Framework Exception — the standard exception class for the X33S web framework. |
| X33S | Framework | X33 Standard — K-Opticom's proprietary Java web framework for telecommunications billing/service management. |
| `X33VDataTypeBeanInterface` | Interface | Interface for data-type-aware beans in the X33V view framework — defines `typeModelData`, `listKoumokuIds`, etc. |
| `X33VDataTypeStringBean` | Class | Framework bean wrapping a String-typed data model field. |
| `X33VDataTypeList` | Class | Framework collection class for list-type (repeating) data model fields. |
| KKW01031SF | Module | A K-Opticom screen module for campaign management — part of the WEBVIEW tier handling campaign data display and maintenance. |
| DBean | Suffix | Data Bean — a view-model class that holds and manages screen data in the X33S MVC pattern. |
| Bean | Term | A Java bean following the X33S framework's data-binding conventions. |
| コマンド | Japanese | Command — a screen action/operation code in the X33S framework. |
| 項目 | Japanese | Field / item — a data element in the screen's data model (koumoku). |
| サブキー | Japanese | Sub-key — a property descriptor within a field (subkey). |
| フラグ | Japanese | Flag — a boolean-like indicator field (from English "flag"). |
| キャンペーン | Japanese | Campaign — a marketing promotion or service campaign. |
| 契約 | Japanese | Contract — a service subscription agreement. |
| 種別 | Japanese | Type / category — the classification of something. |
| 番号 | Japanese | Number — a record identifier or sequence number. |
| 件数 | Japanese | Count — number of items (from 件, a counter for documents/events). |
| 更新 | Japanese | Update — modification of existing data. |
| 年月日 | Japanese | Year-month-day — a date. |
| 開始 | Japanese | Start — commencement. |
| 終了 | Japanese | End — termination. |
| タイプ | Japanese | Type — a classification category. |
| 名称 | Japanese | Name — human-readable label. |
| ステータス | Japanese | Status — current state or condition. |
| 即時適用 | Japanese | Immediate apply — changes take effect without delay. |