liuyao 0.5.1 → 1.0.0

package/README.md

@@ -1,123 +1,97 @@
 # liuyao
 
-Metadata and utility classes for Chinese Liu Yao divination. This package provides typed models for yao lines and hexagrams, along with traditional metadata derived from sources such as Zeng Shan Bu Yi.
+六爻卦象元数据与装卦工具。数据取自《增删卜易》等著作，只做数据建模，不包含解卦逻辑。
 
-For more packages, see [my homepage](https://baendlorel.github.io/?repoType=npm).
+更多包见[我的主页💛](https://baendlorel.github.io/?repoType=npm)
 
-## Features
+_受@lsby的启发_ 现已重写为中文版，并进行了极大简化，仍然高效地保持了原有功能。
 
-- Create a yao from its Yang-count representation, quaternary or various arguments.
-- Build a hexagram from six Yao lines or from a known hexagram name.
-- Inspect hexagram metadata such as its name, palace, phase, and setup information.
-- Derive the changed hexagram for dynamic lines.
-- Access Six God ordering data for different heavenly stems.
+**语义更加清晰，但所有api均已破坏性变更，并发布v1.0**
 
-## Skill Pack
-This packages includes a 'liuyao-skill' directory that can parse a hexagram string and date into a structured JSON output. It is used for agents to divination and interpretation.  See the [SKILL.md](./src/SKILL.md) for details.
-> I tried it, very handy.
-
-## Installation
+## 安装
 
 ```bash
 pnpm add liuyao
 ```
 
-## Quick Start
+## 快速开始
 
 ```ts
-import { Hexagram, Yao, SixGodList } from 'liuyao';
+import { 六爻卦, 爻 } from 'liuyao';
 
-const hexagram = Hexagram.fromQuaternary('111222'); // gets a Hexagram instance of '地天泰'
+const 卦 = 六爻卦.从卦名创建('天风姤');
 
-if (hexagram === null) {
-	throw new Error('Invalid hexagram');
+if (卦) {
+  console.log(卦.全名); // 天风姤
+  console.log(卦.宫位信息); // 乾宫（金）一世卦
+  console.log(卦.六亲干支五行); // ['父母辛丑土', '子孙辛亥水', ...]
+  console.log(卦.六冲六合); // undefined（不是六冲也不是六合）
+  console.log(卦.变().全名); // 动爻变化后的卦，静卦返回自身
+  console.log(卦.世爻, 卦.应爻); // 世应所在的爻index，0 为初爻
 }
-
-console.log(hexagram.info.id);
-console.log(hexagram.toDescriptionEn());
-console.log(hexagram.toChanged()?.info.id);
-console.log(SixGodList[0]);
 ```
 
-## Core Concepts
-
-### Yao
+## 核心概念
 
-A yao is one line in a hexagram. The constructor accepts a yang count from `0` to `3`:
+### 爻
 
-- `0`: old yin, dynamic
-- `1`: young yang, static
-- `2`: young yin, static
-- `3`: old yang, dynamic
-
-Example:
+一个爻由「阳数」0–3 表示，对应老阴、少阳、少阴、老阳；0 和 3 是动爻。
 
 ```ts
-import { Yao } from 'liuyao';
-
-const yao = new Yao(3);
-
-console.log(yao.name);
-console.log(yao.symbol);
-console.log(yao.isDynamic);
+const 爻1 = new 爻(3);
+爻1.名称; // 老阳
+爻1.阴阳; // 阳
+爻1.符号; // 重
+爻1.动静状态; // 动未变
+爻1.变().名称; // 少阴
 ```
 
-### Hexagram
+### 六爻卦
 
-A hexagram contains six yao lines ordered from bottom to top.
+六个爻从初爻到上爻排列。构造时自动完成装六亲、装天干、装世应、判六冲六合。
 
 ```ts
-import { Hexagram } from 'liuyao';
-
-const qian = Hexagram.fromId('乾为天');
-
-if (qian) {
-	console.log(qian.info.sign);
-	console.log(qian.info.phase);
-	console.log(qian.dynamicInner);
-}
+const 卦 = 六爻卦.从阳数字符串创建('112233'); // '单单拆拆重重' 等价
+卦?.全名; // 风泽中孚
+卦?.二进制表示; // '110011'，1 为阳爻，0 为阴爻
 ```
 
-Useful instance members:
+## API
 
-- `info`: metadata for the current hexagram
-- `isDynamic`: whether any line is dynamic
-- `isChanged`: whether the current hexagram is already a changed hexagram
-- `toChanged()`: returns the changed hexagram when dynamic lines exist
-- `toDescription()`: Chinese description
-- `toDescriptionEn()`: English description
+### 爻
 
-Useful factory methods:
+| 静态方法              | 说明                                          |
+| --------------------- | --------------------------------------------- |
+| `从阳数字符串创建(s)` | `'0'`–`'3'`                                   |
+| `从单拆重交创建(s)`   | `'交'` `'单'` `'拆'` `'重'`                   |
+| `从名称创建(s)`       | `'老阴'` `'少阳'` `'少阴'` `'老阳'`           |
+| `从八卦字段创建(v)`   | 八卦的卦名、二进制、阳数、符号均可，如 `'乾'` |
 
-- `Hexagram.fromYaos(yaos)`
-- `Hexagram.fromyangs(counts)`
-- `Hexagram.fromId(id)`
-- `Hexagram.fromPalace(palace)`
+实例：`阳数`、`阴阳`、`名称`、`符号`、`动静状态`、`变()`、`克隆()`。
 
-## Exported API
+### 六爻卦
 
-The package currently exports:
+| 静态方法              | 说明                                          |
+| --------------------- | --------------------------------------------- |
+| `从阳数字符串创建(s)` | 如 `'112233'`                                 |
+| `从单拆重交创建(s)`   | 如 `'单单拆拆重重'`                           |
+| `从阳数创建(counts)`  | 阳数数组，非法时返回 `null`                   |
+| `从卦名创建(name)`    | 全名、卦名或唯一前缀，如 `'天火同人'`、`'姤'` |
 
-**Classes:**
-- `Hexagram`
-- `Yao`
+实例：`六爻`、`阳数`、`二进制表示`、`卦名`、`全名`、`符号`、`五行`、`宫`、`八宫卦位`、`宫位信息`、`动静状态`、`六亲干支五行`、`世爻`、`应爻`、`六冲六合`、`是否为八纯卦`、`内卦`、`外卦`、`变()`、`克隆()`。
 
-**Data Lists:**
-- `HexagramList`(六十四卦): Includes 64 static hexagram info objects with traditional metadata.
-- `HexagramYaoIndex`(六十四卦爻位名)
-- `TrigramList`(八卦): Includes 8 static trigram info objects with traditional metadata.
-- `SixGodList`(六神表)
+### 数据表
 
-**Types:**
-- type `SixGod`
-- type `SixGodInfo`
-- type `SetupGramInfo`
+`六十四卦表`、`八卦表`、`八宫卦位顺序表`、`六神表`、`爻位`。
 
-## Notes
+## 技能包
 
-- Traditional names and metadata values are kept in Chinese.
-- The package focuses on data modeling and lookup. It does not implement a full divination workflow by itself.
+包内附带 `liuyao-skill`，供 AI 用脚本把卦象字符串装成结构化数据，详见 [SKILL.md](./src/SKILL.md)。
+
+```bash
+node parser.skill.mjs <卦象字符串> [--date=<日期>] [--format=<格式>]
+```
 
-## License
+`--format` 可选 `json`（默认，紧凑）、`pretty-json`（缩进 2 格）、`yaml`、`md`（排盘表格）。卦象字符串支持六位阳数 `112233`、六位单拆重交 `单单拆拆重重`、卦名或全名 `天风姤`。日期用 `--date` 传入，如 `--date=2026-10-31T13:00`（`new Date` 对纯日期按 UTC 零点解析，会固定成辰时、UTC 以西还会退一天，请写全时间）。参数不合法时会打印具体原因和用法并以非 0 退出。
 
-MIT
+`src/lib` 下的 `toJSON`、`toYAML`、`toMarkdown` 即上述三种结构化输出的实现。

package/dist/index.d.mts

@@ -1,45 +1,40 @@
 //#region src/core/common.d.ts
-declare const PalaceOrderTable: string[];
-type BranchPhase = '子水' | '寅木' | '辰土' | '午火' | '申金' | '戌土' | '寅木' | '辰土' | '午火' | '申金' | '戌土' | '子水' | '辰土' | '午火' | '申金' | '戌土' | '子水' | '寅木' | '子水' | '寅木' | '辰土' | '午火' | '申金' | '戌土' | '丑土' | '亥水' | '酉金' | '未土' | '巳火' | '卯木' | '卯木' | '丑土' | '亥水' | '酉金' | '未土' | '巳火' | '未土' | '巳火' | '卯木' | '丑土' | '亥水' | '酉金' | '巳火' | '卯木' | '丑土' | '亥水' | '酉金' | '未土';
-type Phase = '金' | '木' | '水' | '火' | '土';
-type TrigramName = '乾' | '兑' | '离' | '震' | '巽' | '坎' | '艮' | '坤';
-interface HexagramInfo {
+declare const 八宫卦位顺序表: readonly ["本宫卦", "一世卦", "二世卦", "三世卦", "四世卦", "五世卦", "游魂卦", "归魂卦"];
+type 地支五行 = '子水' | '丑土' | '寅木' | '卯木' | '辰土' | '巳火' | '午火' | '未土' | '申金' | '酉金' | '戌土' | '亥水';
+type 五行 = '金' | '木' | '水' | '火' | '土';
+type 八卦名 = '乾' | '兑' | '离' | '震' | '巽' | '坎' | '艮' | '坤';
+interface 六十四卦 {
   /**
    * Binary representation of the hexagram, where 0 image a yin line and 1 image a yang line. The lines are ordered from the bottom (first line) to the top (sixth line).
    */
-  binary: string;
-  /**
-   * Binary to yangs.
-   * e.g. `'000000'` 坤为地 -> `[2, 2, 2, 2, 2, 2]`, 2 means Shao Yin.
-   */
-  yangs: number[];
+  二进制表示: string;
   /**
    * Full name of the hexagram, which includes the names of the upper and lower trigrams.
    *
    * For example, "坤为地", "地雷复", "地水师", etc.
    */
-  id: string;
+  全名: string;
   /**
    * Name of the hexagram.
    *
    * For example, "地", "复", "师", etc.
    */
-  name: string;
+  卦名: string;
   /**
    * 64 hexagrams correspond to Unicode characters.
    * For example, "䷁" (U+4DC1) image the hexagram "坤为地".
    */
-  sign: string;
+  符号: string;
   /**
    * Five Phases (五行) associated with the hexagram, which can be one of "金" (Metal), "木" (Wood), "水" (Water), "火" (Fire), or "土" (Earth).
    * It indicates the development and state of things.
    */
-  phase: Phase;
+  五行: 五行;
   /**
    * Eight Palaces (八宫) to which the hexagram belongs.
    * 'Palace' is not a physical palace, but rather a category or family of hexagrams.
    */
-  palace: TrigramName;
+  宫: 八卦名;
   /**
    * Index of the hexagram within its palace, ranging from 0 to 7. This index helps to identify the specific hexagram within the context of its palace.
    *
@@ -52,88 +47,67 @@ interface HexagramInfo {
    * - 游魂卦 Wandering Soul, restores 4th yao of Fifth Generation
    * - 归魂卦 Returning Soul, restores lower 3 yaos of Fifth Generation
    */
-  generation: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+  八宫卦位: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
 }
-declare const HexagramInfoTable: readonly HexagramInfo[];
-interface TrigramInfo {
+/**
+ * 包含丰富信息的表，已冻结无法修改，字段如下：
+ *  - 二进制表示: '000000'
+ *  - 全名: '坤为地'
+ *  - 符号: '䷁'
+ *  - 五行: '土'
+ *  - 宫: '坤'
+ *  - 卦位: 0
+ *  - 卦名: '坤'
+ */
+declare const 六十四卦表: readonly 六十四卦[];
+interface 八卦 {
   /**
    * Presents the trigram as a 3-digit binary string. 1 image a Yang line and 0 image a Yin line.
    *
    * For example, "111" for 乾, "100" for 震, etc.
    */
-  binary: `${0 | 1}${0 | 1}${0 | 1}`;
+  二进制表示: `${0 | 1}${0 | 1}${0 | 1}`;
   /**
    * How many Yang Yaos are in the trigram, such as 0 for 坤, 1 for 震, 2 for 兑, etc.
    */
-  yangs: 0 | 1 | 2 | 3;
+  阳数: 0 | 1 | 2 | 3;
   /**
    * Name of the trigram in Chinese, such as "乾", "坤", "震", etc.
    */
-  id: string;
+  卦名: string;
   /**
    * "象", means what the trigram represents in Chinese, such as "天", "地", "水", etc.
    */
-  image: string;
+  象: string;
   /**
    * Unicode character representing the trigram, such as "☰" for 乾, "☷" for 坤, etc.
    */
-  sign: string;
+  符号: string;
   /**
    * Earth Stem and Five Phases when this gram performs a inner gram of a hexagram.
    * @see 《增删卜易·浑天甲子章》
    */
-  inner: BranchPhase[];
+  内卦地支五行: 地支五行[];
   /**
    * Earth Stem and Five Phases when this gram performs a outer gram of a hexagram.
    * @see 《增删卜易·浑天甲子章》
    */
-  outer: BranchPhase[];
+  外卦地支五行: 地支五行[];
 }
 /**
  * List of all trigrams in the I Ching, with their binary representation, number of yang lines, name, what they represent, and their corresponding sign.
  */
-declare const TrigramInfoTable: readonly TrigramInfo[];
-//#endregion
-//#region src/core/setup-gram.d.ts
-/**
- * Kins and their corresponding earthly branches in the Liu Yao divination system, along with the type of relation (世 or 应).
- * This information is crucial for interpreting the hexagrams and their changing lines in the context of a divination reading.
- *
- * @deprecated This is for beginners.
- */
-interface SetupGramInfo {
-  /**
-   * There are 5 kins in total.
-   *
-   * - 兄弟 (Brothers): Representing peers, friends, or competitors.
-   * - 妻财 (Wife/Wealth): Representing spouse, wealth, or resources.
-   * - 子孙 (Children/Descendants): Representing offspring, students, or followers.
-   * - 官鬼 (Officials/Ghosts): Representing authority figures, adversaries, or hidden factors.
-   * - 父母 (Parents): Representing parents, mentors, or foundational influences.
-   *
-   * Each kin is associated with one of the twelve earthly branches (地支), which adds another layer of meaning to the hexagram lines.
-   */
-  kin: '兄弟丑土' | '兄弟亥水' | '兄弟午火' | '兄弟卯木' | '兄弟子水' | '兄弟寅木' | '兄弟巳火' | '兄弟戌土' | '兄弟未土' | '兄弟申金' | '兄弟辰土' | '兄弟酉金' | '妻财丑土' | '妻财亥水' | '妻财午火' | '妻财卯木' | '妻财子水' | '妻财寅木' | '妻财巳火' | '妻财戌土' | '妻财未土' | '妻财申金' | '妻财辰土' | '妻财酉金' | '子孙丑土' | '子孙亥水' | '子孙午火' | '子孙卯木' | '子孙子水' | '子孙寅木' | '子孙巳火' | '子孙戌土' | '子孙未土' | '子孙申金' | '子孙辰土' | '子孙酉金' | '官鬼丑土' | '官鬼亥水' | '官鬼午火' | '官鬼卯木' | '官鬼子水' | '官鬼寅木' | '官鬼巳火' | '官鬼戌土' | '官鬼未土' | '官鬼申金' | '官鬼辰土' | '官鬼酉金' | '父母丑土' | '父母亥水' | '父母午火' | '父母卯木' | '父母子水' | '父母寅木' | '父母巳火' | '父母戌土' | '父母未土' | '父母申金' | '父母辰土' | '父母酉金';
-  /**
-   * Host（世）is the augur and Guest（应） is the person or things which to ask about.
-   *
-   * Indexes of Host and Guest satisfies this formula:
-   * ```js
-   * index_guest = (index_host + 3) % 6
-   * ```
-   */
-  hostGuest?: '世' | '应';
-}
+declare const 八卦表: readonly 八卦[];
 //#endregion
 //#region src/core/six-gods.d.ts
-type SixGod = '玄武' | '白虎' | '螣蛇' | '勾陈' | '朱雀' | '青龙';
-interface SixGodInfo {
+type 六神 = '玄武' | '白虎' | '螣蛇' | '勾陈' | '朱雀' | '青龙';
+interface 六神信息 {
   /**
    * The Heavenly Stem associated with the Six Gods in this order.
    * They are '甲乙丙丁戊己庚辛壬癸' in sequence.
    * Different Heavenly Stems correspond to different orders of Six Gods.
    */
-  heavenlyStem: string;
+  天干: string;
   /**
    * Six Gods contains '青龙', '朱雀', '勾陈', '螣蛇', '白虎', '玄武'.
    * Different Heavenly Stems correspond to different orders of Six Gods.
@@ -146,53 +120,47 @@ interface SixGodInfo {
    * - 螣蛇: Flying Serpent, a limbless divine serpent that can summon clouds and mist and roam within them.
    * - 勾陈: Gouchen, Also considered as 麒麟 Kylin. It has a body like a musk deer, a tail like that of a dragon, dragon scales, and a single horn.
    */
-  gods: SixGod[];
+  六神: 六神[];
 }
 /**
  * @see 《增删卜易·六神章》
  */
-declare const SixGodTable: readonly SixGodInfo[];
+declare const 六神表: readonly 六神信息[];
 //#endregion
 //#region src/classes/yao.d.ts
-declare class Yao {
-  /**
-   * Returns 老阴、老阳、少阴、少阳
-   */
-  static getName(yangs: number): "老阴" | "少阳" | "少阴" | "老阳";
-  /**
-   * Support creating a Yao from various types of input:
-   * - A symbol representing the Yao (e.g. '交', '单', '拆', '重')
-   * - A name representing the Yao (e.g. '老阴', '少阳', '少阴', '老阳')
-   * - A digit representing the count of yang (e.g. '0', '1', '2', '3')
-   * - Symbols in ancient books representing a Yao ()
-   * - A field of a TrigramInfo object (e.g. id, binary, nameEn, represents, representsEn, sign)
-   * If the input matches any of these, a corresponding Yao will be created.
-   * Otherwise, null will be returned.
-   */
-  /**
-   * Creating a Yao from symbol.
-   * @param symbol e.g. '×' for 0, '’' for 1, '”' for 2, '○' for 3.
-   */
-  static fromSymbol(symbol: string): Yao | null;
+/**
+ * 描述卦和爻的动静变化，分为'静'、'动卦/爻但还没变'、'动卦/爻已经变了'3个状态
+ */
+declare const enum 动静状态 {
+  静 = 0,
+  动未变 = 1,
+  动已变 = 2
+}
+declare class 爻 {
+  #private;
   /**
    * Creating a Yao from symbolName.
    * @param symbolName e.g. '交' for 0, '单' for 1, '拆' for 2, '重' for 3.
+   * @returns 如果入参符合就返回，如果不符合就返回`null`
    */
-  static fromSymbolName(symbolName: string): Yao | null;
+  static 从单拆重交创建(symbolName: string): 爻 | null;
   /**
    * Creating a Yao from name.
    * @param name e.g. '老阴', '少阳', '少阴', '老阳'.
+   * @returns 如果入参符合就返回，如果不符合就返回`null`
    */
-  static fromName(name: string): Yao | null;
+  static 从名称创建(name: string): 爻 | null;
   /**
-   * Create a Yao from a digit string representing the count of yang.
+   * @param digit e.g. '0', '1', '2', '3'.
+   * @returns 如果入参符合就返回，如果不符合就返回`null`
    */
-  static fromDigitString(digit: string): Yao | null;
+  static 从阳数字符串创建(digit: string): 爻 | null;
   /**
    * Create a Yao from any Trigram field value.
    * @param value `{id: '坤', binary: '000', yangs: 0}`, so `'坤'`, `'000'` and `0` can all be used.
+   * @returns 如果入参符合就返回，如果不符合就返回`null`
    */
-  static fromTrigramField(value: string | number): Yao | null;
+  static 从八卦字段创建(value: string | number): 爻 | null;
   /**
    * How many faces of character of 3 coins in this Yao.
    * It can only be 0, 1, 2 or 3, which corresponds to 老阴、少阳、少阴、老阳 respectively.
@@ -201,134 +169,111 @@ declare class Yao {
    * - 2: 少阴 (two coins are 阳面, one coin is 阴面)
    * - 3: 老阳 (all three coins are 阳面)
    */
-  readonly yangs: 0 | 1 | 2 | 3;
+  get 阳数(): 0 | 1 | 2 | 3;
+  get 动静状态(): 动静状态;
   /**
    * 两仪, aka 阴阳
    */
-  readonly polar: 0 | 1;
+  get 阴阳(): '阴' | '阳';
+  get 名称(): '老阴' | '少阳' | '少阴' | '老阳';
+  get 符号(): '单' | '拆' | '重' | '交';
+  constructor(阳数: number, 状态?: 动静状态);
   /**
-   * If this Yao is dynamic, which means it can change to another Yao. In LiuYao, only 老阴 and 老阳 are dynamic.
-   * - 老阴 (0) can change to 少阳 (1)
-   * - 老阳 (3) can change to 少阴 (2)
-   * - 少阳 (1) and 少阴 (2) cannot change, so they are static.
+   * 判断是否同为阴爻或同为阳爻
    */
-  readonly dynamic: boolean;
+  是否阳数相等(other: 爻): boolean;
   /**
-   * Whether this Yao has already changed to another Yao. Once a Yao is changed, it cannot change again.
+   * 判断是否同为阴爻或同为阳爻，且是否变过的状态也相同
+   * - 阳数和状态相同视为全同
    */
-  readonly changed: boolean;
-  /**
-  * The symbol representing this Yao, which is one of '×', '’', '”', '○'.
-  */
-  readonly pattern: '×' | '’' | '”' | '○';
-  readonly name: '老阴' | '少阳' | '少阴' | '老阳';
-  readonly symbol: '单' | '拆' | '重' | '交';
-  constructor(yangs: number, isChanged?: boolean);
+  是否全同(other: 爻): boolean;
   /**
-   * Consider the Yaos are same if `this.yangs` is same
+   * 克隆一个全新的和本身一样的爻对象
    */
-  eq(other: Yao): boolean;
+  克隆(): 爻;
   /**
-   * Consider the Yaos are `===` if:
-   * 1. `this.yangs` is same
-   * 2. `this.isChanged` is same
+   * 得到新的爻对象，这个爻是变过的。
+   * @returns 如果是静爻或者已变过，则返回它自己
    */
-  eqeqeq(other: Yao): boolean;
-  clone(): Yao;
-  toChanged(): Yao;
+  变(): 爻;
 }
 //#endregion
 //#region src/classes/hexagram.d.ts
-type LiuYao = [Yao, Yao, Yao, Yao, Yao, Yao];
-declare const HexagramYaoOrder: readonly ["初爻", "二爻", "三爻", "四爻", "五爻", "上爻"];
+declare const 爻位: readonly ["初爻", "二爻", "三爻", "四爻", "五爻", "上爻"];
 /**
  * Hexagram class represents a hexagram, which consists of 6 Yao.
  * - Each Yao can be either yin or yang, and can be changing or not.
  * - The hexagram can be constructed from an array of Yao or an array of counts of yang.
  * - Creates “乾为天” by default.
  */
-declare class Hexagram implements HexagramInfo {
+declare class 六爻卦 implements 六十四卦 {
+  #private;
   /**
    * Use tokens like `'012132'` to create a Hexagram, where each digit represents the count of Yang in the corresponding Yao (0 for 老阴, 1 for 少阳, 2 for 少阴, 3 for 老阳). The first digit represents the first Yao (初爻) and the last digit represents the sixth Yao (上爻).
    */
-  static fromQuaternary(quaternary: string): Hexagram | null;
+  static 从阳数字符串创建(quaternary: string): 六爻卦 | null;
   /**
    * Use tokens like `'单单拆拆重重'` to create a Hexagram.
    *
    * Since 交 is 0, 单 is 1, 拆 is 2, and 重 is 3, the above token is equivalent to '112233'.
    * Which returns '风泽中孚' with its 5th and 6th Yao being dynamic.
    */
-  static fromSymbolName(symbolNames: string): Hexagram | null;
+  static 从单拆重交创建(symbolNames: string): 六爻卦 | null;
   /**
    * Try to create a Hexagram from an array of counts of Yang. If the input is invalid, null will be returned.
    */
-  static fromYangCounts(counts: number[]): Hexagram | null;
+  static 从阳数创建(counts: number[]): 六爻卦 | null;
   /**
    * Create a Hexagram from its id, which is the name of the hexagram without the palace name.
-   * @param id "坤为地", "地雷复", "地水师"
-   */
-  static fromId(id: string): Hexagram | null;
-  /**
-   * Find Original Palace Hexagram by the palace name, which is the last character of the hexagram id. For example, '天' for '乾为天', '地' for '坤为地', etc.
-   */
-  static fromPalace(palace: string): Hexagram | null;
-  /**
-   * 6 Yao positions, indexed from bottom to top.
-   * Index from 0 to 5, where 0 is the first Yao (初爻) and 5 is the sixth Yao (上爻).
-   */
-  readonly yaos: LiuYao;
-  readonly yangs: number[];
-  readonly binary: string;
-  readonly id: string;
-  readonly name: string;
-  readonly sign: string;
-  readonly palace: '乾' | '坤' | '震' | '巽' | '坎' | '离' | '艮' | '兑';
-  readonly phase: '金' | '木' | '水' | '火' | '土';
-  readonly generation: 0 | 6 | 1 | 2 | 3 | 4 | 5 | 7;
-  readonly palaceInfo: string;
-  /**
-   * Whether the 6 Yaos of this hexagram contain any dynamic Yao.
-   */
-  readonly dynamic: boolean;
-  /**
-   * Whether this hexagram has already changed to another hexagram. Once a hexagram is changed, it cannot change again.
-   */
-  readonly changed: boolean;
-  readonly inner: TrigramInfo;
-  readonly outer: TrigramInfo;
-  /**
-   * Whether this gram is 六冲、六合
+   * @param name "坤为地", "地雷复", "地水师"
    */
-  readonly specialType?: '六冲' | '六合';
+  static 从卦名创建(name: string): 六爻卦 | null;
   /**
-   * Whether this gram is "八纯卦"
-   */
-  readonly pure: boolean;
-  /**
-   * Includes 六亲、天干、地支、五行. Looks like "兄弟癸丑土" "官鬼辛卯木"
+   * Create a Hexagram from an array of Yao with length 6.
+   * @param 六爻 从初爻到上爻6个爻组成的数组
+   * @param 状态 动静状态，不传则由爻推断
+   * @param 本卦 仅变卦需要传入。六亲在构造时就要按本卦的宫装好，所以不能等构造完再赋值
    */
-  readonly kins: string[];
+  constructor(六爻: 爻[], 状态?: 动静状态, 本卦?: 六爻卦);
+  get 六爻(): [爻, 爻, 爻, 爻, 爻, 爻];
+  get 阳数(): number[];
+  get 宫位信息(): string;
+  get 动静状态(): 动静状态;
   /**
-   * Index of the 世爻
+   * 若是变卦，则返回本卦。
+   *
+   * 若是静卦或者本来就是本卦，则返回自身。
    */
-  readonly host: number;
+  get 本卦(): 六爻卦;
+  get 六亲干支五行(): string[];
   /**
-   * Index of the 应爻
+   * 返回世爻所在的index（0表示初爻，5表示上爻）
    */
-  readonly guest: number;
+  get 世爻(): 0 | 1 | 2 | 3 | 4 | 5;
   /**
-   * if it is a changed gram, this points to the primary one.
+   * 返回应爻所在的index（0表示初爻，5表示上爻）
    */
-  readonly primary: Hexagram | null;
+  get 应爻(): 0 | 1 | 2 | 3 | 4 | 5;
+  get 六冲六合(): '六冲' | '六合' | undefined;
+  get 是否为八纯卦(): boolean;
+  get 内卦(): 八卦;
+  get 外卦(): 八卦;
+  get 二进制表示(): string;
+  get 卦名(): string;
+  get 全名(): string;
+  get 符号(): string;
+  get 五行(): 五行;
+  get 宫(): 八卦名;
+  get 八宫卦位(): 0 | 6 | 1 | 2 | 3 | 4 | 5 | 7;
   /**
-   * Create a Hexagram from an array of Yao with length 6.
+   * 获得变爻卦象
+   * @returns 变爻卦象，如果卦象静则返回它自己
    */
-  constructor(yaos: Yao[], primary?: Hexagram | null);
-  toChanged(): Hexagram | null;
-  clone(): Hexagram;
+  变(): 六爻卦;
+  克隆(): 六爻卦;
   toString(): string;
   [Symbol.toPrimitive](): string;
 }
 //#endregion
-export { Hexagram, type HexagramInfo, HexagramInfoTable, HexagramYaoOrder, PalaceOrderTable, type SetupGramInfo, type SixGod, type SixGodInfo, SixGodTable, type TrigramInfo, TrigramInfoTable, Yao };
+export { type 八卦, 八卦表, 八宫卦位顺序表, type 六十四卦, 六十四卦表, 六爻卦, type 六神, type 六神信息, 六神表, 爻, 爻位 };
 //# sourceMappingURL=index.d.mts.map