VNLEWIKI物語をつくる。世界をつなぐ。
日本語
VNLEガイド

JSONフィールドリファレンス

実行データとコンテンツ

formatとcontainerVersionがデータ形式を識別します。executionには開始地点とノード、contentには文章、翻訳、各種項目が入ります。表同士はUUIDで結び付け、表示名で参照しないでください。JSONにはコメントを書けないため、説明は外に分けてサンプルを有効なJSONに保っています。

// Explanation only — not a JSON file
// execution.entries[entryId].nodeRef -> execution.nodes[nodeId]
// node.text.textRef -> content.texts[textId].sourceMessage
// content.translations[locale][textId].message -> translated segments
// dialogue.continuation.nodeRef -> next node
// end -> stop; never keep advancing

story.json

言語の切り替えと未翻訳の扱い

言語は現在のノードとは別に保存します。切り替えたら同じtextRefを再取得し、localeの翻訳があれば使い、なければsourceMessageを使います。言語の表がない場合も未翻訳として扱います。allowEmptyは意図的な空欄に対応します。プレースホルダーは型に従って表示し、JSONそのものを文字列化しないでください。翻訳が古いかどうかは原文のフィンガープリントで判断します。workflowStatusだけでは新しさを判断できません。

現在のエクスポートスキーマから参照されるすべての定義を掲載しています。以下には全プロパティ、形式の違い、制約が含まれます。Schemaを開くと入れ子のルールも確認できます。additionalPropertiesがfalseの場所では、余分なフィールドは認められません。

JSON Schema · Draft 2020-12

Capability

フィールド型／必須意味／ルール
Schema · Capability
{
  "type": "string",
  "pattern": "^[a-z][a-z0-9.-]*$",
  "title": "Capability"
}

ContentAsset

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
mediaTypestring · 必須メディアコンテンツのMIMEタイプ。
relativePathRelativePath · 必須検証済みの相対アセットパス。確認せずにファイルシステムのパスとして使用しないでください。
contentHashHash · 必須参照されたメディアバイトのSHA-256。
displayNamestring · 必須人が読み取れるアセットの表示名。
licenseNotestringアセットのライセンスに関するメモ。法的な確認が自動で行われるわけではありません。
widthinteger構造と有効な値は、型とスキーマを参照してください。
{"minimum":0,"maximum":2147483647}
heightinteger構造と有効な値は、型とスキーマを参照してください。
{"minimum":0,"maximum":2147483647}
byteSizeinteger構造と有効な値は、型とスキーマを参照してください。
{"minimum":0,"maximum":2147483647}
originalNamestring構造と有効な値は、型とスキーマを参照してください。
Schema · ContentAsset
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "mediaType": {
      "type": "string"
    },
    "relativePath": {
      "$ref": "#/$defs/RelativePath"
    },
    "contentHash": {
      "$ref": "#/$defs/Hash"
    },
    "displayName": {
      "type": "string"
    },
    "licenseNote": {
      "type": "string"
    },
    "width": {
      "type": "integer",
      "minimum": 0,
      "maximum": 2147483647
    },
    "height": {
      "type": "integer",
      "minimum": 0,
      "maximum": 2147483647
    },
    "byteSize": {
      "type": "integer",
      "minimum": 0,
      "maximum": 2147483647
    },
    "originalName": {
      "type": "string"
    }
  },
  "required": [
    "id",
    "mediaType",
    "relativePath",
    "contentHash",
    "displayName"
  ],
  "additionalProperties": false,
  "title": "ContentAsset"
}

ContentCharacter

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
keyKey · 必須人が読める固定キー。技術的な参照にはIDを使います。
nameTextRefId · 必須ローカライズされた名前のテキストID。
colorstring · 必須キャラクターの表示色。ロジックに使う値ではありません。
{"pattern":"^#[0-9a-fA-F]{6}$"}
defaultPortraitRefIdキャラクターの標準ポートレート用アセット。汎用エクスポートには含まれません。
emotionsobject · 必須感情ID→感情定義。
{"additionalProperties":{"$ref":"#/$defs/Emotion"}}
emotions[key]Emotion構造と有効な値は、型とスキーマを参照してください。
Schema · ContentCharacter
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "nameTextRef": {
      "$ref": "#/$defs/Id"
    },
    "color": {
      "type": "string",
      "pattern": "^#[0-9a-fA-F]{6}$"
    },
    "defaultPortraitRef": {
      "$ref": "#/$defs/Id"
    },
    "emotions": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/Emotion"
      }
    }
  },
  "required": [
    "id",
    "name",
    "key",
    "nameTextRef",
    "color",
    "emotions"
  ],
  "additionalProperties": false,
  "title": "ContentCharacter"
}

ContentCommandDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
keyKey · 必須人が読める固定キー。技術的な参照にはIDを使います。
categorystring · 必須定義を整理するのに使用されるカタログカテゴリ。
inputsArray<ParameterDefinition> · 必須名前と型を持つシグネチャの入力項目。
outcomesArray<OutcomeDefinition> · 必須コマンドが返し得る結果の名前と、そのデータ契約およびバインディング。
{"minItems":1}
descriptionstring作成者が記述した説明。実行可能な命令ではありません。
Schema · ContentCommandDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "category": {
      "type": "string"
    },
    "inputs": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/ParameterDefinition"
      }
    },
    "outcomes": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/OutcomeDefinition"
      },
      "minItems": 1
    },
    "description": {
      "type": "string"
    }
  },
  "required": [
    "id",
    "name",
    "key",
    "category",
    "inputs",
    "outcomes"
  ],
  "additionalProperties": false,
  "title": "ContentCommandDefinition"
}

ContentItemDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
keyKey · 必須人が読める固定キー。技術的な参照にはIDを使います。
nameTextRefId · 必須ローカライズされた名前のテキストID。
descriptionTextRefId翻訳可能な説明文のテキストID。
iconAssetRefIdカタログアイコンのアセットID。
Schema · ContentItemDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "nameTextRef": {
      "$ref": "#/$defs/Id"
    },
    "descriptionTextRef": {
      "$ref": "#/$defs/Id"
    },
    "iconAssetRef": {
      "$ref": "#/$defs/Id"
    }
  },
  "required": [
    "id",
    "name",
    "key",
    "nameTextRef"
  ],
  "additionalProperties": false,
  "title": "ContentItemDefinition"
}

ContentLocationDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
keyKey · 必須人が読める固定キー。技術的な参照にはIDを使います。
nameTextRefId · 必須ローカライズされた名前のテキストID。
descriptionTextRefId翻訳可能な説明文のテキストID。
previewAssetRefIdプレビューリソースのアセットID。
Schema · ContentLocationDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "nameTextRef": {
      "$ref": "#/$defs/Id"
    },
    "descriptionTextRef": {
      "$ref": "#/$defs/Id"
    },
    "previewAssetRef": {
      "$ref": "#/$defs/Id"
    }
  },
  "required": [
    "id",
    "name",
    "key",
    "nameTextRef"
  ],
  "additionalProperties": false,
  "title": "ContentLocationDefinition"
}

ContentMinigameDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
keyKey · 必須人が読める固定キー。技術的な参照にはIDを使います。
nameTextRefIdローカライズされた名前のテキストID。
commandRefId · 必須実行するゲームコマンドのID。
Schema · ContentMinigameDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "nameTextRef": {
      "$ref": "#/$defs/Id"
    },
    "commandRef": {
      "$ref": "#/$defs/Id"
    }
  },
  "required": [
    "id",
    "name",
    "key",
    "commandRef"
  ],
  "additionalProperties": false,
  "title": "ContentMinigameDefinition"
}

ContentQuestDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
keyKey · 必須人が読める固定キー。技術的な参照にはIDを使います。
titleTextRefId · 必須ローカライズされたタイトルのテキストID。
descriptionTextRefId翻訳可能な説明文のテキストID。
objectiveDefinitionsArray<QuestObjective> · 必須クエスト目標ID → 目標の定義。
Schema · ContentQuestDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "titleTextRef": {
      "$ref": "#/$defs/Id"
    },
    "descriptionTextRef": {
      "$ref": "#/$defs/Id"
    },
    "objectiveDefinitions": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/QuestObjective"
      }
    }
  },
  "required": [
    "id",
    "name",
    "key",
    "titleTextRef",
    "objectiveDefinitions"
  ],
  "additionalProperties": false,
  "title": "ContentQuestDefinition"
}

ContentTextEntry

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
keyKey人が読める固定キー。技術的な参照にはIDを使います。
categorystring · 必須定義を整理するのに使用されるカタログカテゴリ。
sourceMessageメッセージ · 必須テキストとプレースホルダーセグメントから作られたソースメッセージ。
placeholdersobject · 必須プレースホルダーキー→タイプ/フォーマット定義。
{"additionalProperties":{"$ref":"#/$defs/PlaceholderDefinition"}}
placeholders[key]PlaceholderDefinition構造と有効な値は、型とスキーマを参照してください。
externalUseboolean · 必須ノードグラフの外で使用されるテキストをマークします。
Schema · ContentTextEntry
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "category": {
      "type": "string"
    },
    "sourceMessage": {
      "$ref": "#/$defs/Message"
    },
    "placeholders": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/PlaceholderDefinition"
      }
    },
    "externalUse": {
      "type": "boolean"
    }
  },
  "required": [
    "id",
    "category",
    "sourceMessage",
    "placeholders",
    "externalUse"
  ],
  "additionalProperties": false,
  "title": "ContentTextEntry"
}

ContentVariableDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
keyKey · 必須人が読める固定キー。技術的な参照にはIDを使います。
valueTypeScalarType · 必須想定される値のデータ契約。使用可能なエンティティの型を含みます。
defaultValueScalarValue · 必須型を持つ初期値／既定値。
descriptionstring作成者が記述した説明。実行可能な命令ではありません。
Schema · ContentVariableDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "key": {
      "$ref": "#/$defs/Key"
    },
    "valueType": {
      "$ref": "#/$defs/ScalarType"
    },
    "defaultValue": {
      "$ref": "#/$defs/ScalarValue"
    },
    "description": {
      "type": "string"
    }
  },
  "required": [
    "id",
    "name",
    "key",
    "valueType",
    "defaultValue"
  ],
  "additionalProperties": false,
  "title": "ContentVariableDefinition"
}

Emotion

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
portraitRefId感情に対応するポートレートのアセット。汎用エクスポートには含まれません。
Schema · Emotion
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "portraitRef": {
      "$ref": "#/$defs/Id"
    }
  },
  "required": [
    "id",
    "name"
  ],
  "additionalProperties": false,
  "title": "Emotion"
}

EntityType

フィールド型／必須意味／ルール
Schema · EntityType
{
  "type": "string",
  "enum": [
    "item",
    "quest",
    "location",
    "minigame",
    "asset"
  ],
  "title": "EntityType"
}

EntryRef

フィールド型／必須意味／ルール
flowRefId · 必須シーン／サブストーリーのID。
entryRefId · 必須指定されたフロー内のエントリーID。
Schema · EntryRef
{
  "type": "object",
  "properties": {
    "flowRef": {
      "$ref": "#/$defs/Id"
    },
    "entryRef": {
      "$ref": "#/$defs/Id"
    }
  },
  "required": [
    "flowRef",
    "entryRef"
  ],
  "additionalProperties": false,
  "title": "EntryRef"
}

ExecutableChoiceOption

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
textExecutableTextUse · 必須テキストセグメントでは文章そのもの。テキストを参照する箇所ではtextRefとbindings。
conditionExecutableCondition分岐や選択肢の有効化の前に評価する条件。
effectsArray<ExecutableEffect> · 必須アクションノードが順番に適用する状態の変更。
continuationExecutableContinuation · 必須ノードの処理が完了した後の進行先。
Schema · ExecutableChoiceOption
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "text": {
      "$ref": "#/$defs/ExecutableTextUse"
    },
    "condition": {
      "$ref": "#/$defs/ExecutableCondition"
    },
    "effects": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/ExecutableEffect"
      }
    },
    "continuation": {
      "$ref": "#/$defs/ExecutableContinuation"
    }
  },
  "required": [
    "id",
    "text",
    "effects",
    "continuation"
  ],
  "additionalProperties": false,
  "title": "ExecutableChoiceOption"
}

ExecutableCondition

フィールド型／必須意味／ルール
[oneOf 1].kind"compare" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 1].leftExecutableOperand · 必須比較の左辺となる型付きオペランド。
[oneOf 1].operator"eq" | "ne" | "lt" | "lte" | "gt" | "gte" · 必須比較/論理演算子; 許可された値はバリアントに表示されます。
[oneOf 1].rightExecutableOperand · 必須比較の右辺となる型付きオペランド。
[oneOf 2].kind"all" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 2].childrenArray<ExecutableCondition> · 必須複合条件に含まれる子条件。
[oneOf 3].kind"any" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 3].childrenArray<ExecutableCondition> · 必須複合条件に含まれる子条件。
[oneOf 4].kind"not" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 4].childExecutableCondition · 必須単項演算子が対象とする子条件。
Schema · ExecutableCondition
{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "compare"
        },
        "left": {
          "$ref": "#/$defs/ExecutableOperand"
        },
        "operator": {
          "type": "string",
          "enum": [
            "eq",
            "ne",
            "lt",
            "lte",
            "gt",
            "gte"
          ]
        },
        "right": {
          "$ref": "#/$defs/ExecutableOperand"
        }
      },
      "required": [
        "kind",
        "left",
        "operator",
        "right"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "all"
        },
        "children": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/ExecutableCondition"
          }
        }
      },
      "required": [
        "kind",
        "children"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "any"
        },
        "children": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/ExecutableCondition"
          }
        }
      },
      "required": [
        "kind",
        "children"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "not"
        },
        "child": {
          "$ref": "#/$defs/ExecutableCondition"
        }
      },
      "required": [
        "kind",
        "child"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ExecutableCondition"
}

ExecutableContinuation

フィールド型／必須意味／ルール
[oneOf 1].kind"node" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 1].nodeRefId · 必須次の実行可能ノードID。
[oneOf 2].kind"end" · 必須有効なデータ形式を選ぶ識別フィールド。
Schema · ExecutableContinuation
{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "node"
        },
        "nodeRef": {
          "$ref": "#/$defs/Id"
        }
      },
      "required": [
        "kind",
        "nodeRef"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "end"
        }
      },
      "required": [
        "kind"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ExecutableContinuation"
}

ExecutableEffect

フィールド型／必須意味／ルール
[oneOf 1].kind"set" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 1].variableRefId · 必須読み書きする変数の ID 。
[oneOf 1].valueExecutableOperand · 必須リテラル値;宣言されたタイプと一致しなければなりません。
[oneOf 2].kind"add" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 2].variableRefId · 必須読み書きする変数の ID 。
[oneOf 2].valueExecutableOperand · 必須リテラル値;宣言されたタイプと一致しなければなりません。
[oneOf 3].kind"subtract" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 3].variableRefId · 必須読み書きする変数の ID 。
[oneOf 3].valueExecutableOperand · 必須リテラル値;宣言されたタイプと一致しなければなりません。
Schema · ExecutableEffect
{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "set"
        },
        "variableRef": {
          "$ref": "#/$defs/Id"
        },
        "value": {
          "$ref": "#/$defs/ExecutableOperand"
        }
      },
      "required": [
        "kind",
        "variableRef",
        "value"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "add"
        },
        "variableRef": {
          "$ref": "#/$defs/Id"
        },
        "value": {
          "$ref": "#/$defs/ExecutableOperand"
        }
      },
      "required": [
        "kind",
        "variableRef",
        "value"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "subtract"
        },
        "variableRef": {
          "$ref": "#/$defs/Id"
        },
        "value": {
          "$ref": "#/$defs/ExecutableOperand"
        }
      },
      "required": [
        "kind",
        "variableRef",
        "value"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ExecutableEffect"
}

ExecutableEmptyChoice

フィールド型／必須意味／ルール
[oneOf 1].kind"continue" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 1].continuationExecutableContinuation · 必須ノードの処理が完了した後の進行先。
[oneOf 2].kind"fault" · 必須有効なデータ形式を選ぶ識別フィールド。
Schema · ExecutableEmptyChoice
{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "continue"
        },
        "continuation": {
          "$ref": "#/$defs/ExecutableContinuation"
        }
      },
      "required": [
        "kind",
        "continuation"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "fault"
        }
      },
      "required": [
        "kind"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ExecutableEmptyChoice"
}

ExecutableNode

フィールド型／必須意味／ルール
[oneOf 1].idId · 必須安定したID;表示名はキーではありません。
[oneOf 1].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 1].kind"dialogue" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 1].textExecutableTextUse · 必須テキストセグメントでは文章そのもの。テキストを参照する箇所ではtextRefとbindings。
[oneOf 1].speakerRefId話者のキャラクターID。省略時は話者が未指定。
[oneOf 1].emotionRefIdこの会話で選択したキャラクターの感情。
[oneOf 1].continuationExecutableContinuation · 必須ノードの処理が完了した後の進行先。
[oneOf 2].idId · 必須安定したID;表示名はキーではありません。
[oneOf 2].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 2].kind"choice" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 2].optionOrderArray<Id> · 必須表示順に並べた選択肢のID。
[oneOf 2].optionsobject · 必須選択肢ID → 文章、条件、進行先を含む選択肢。
{"additionalProperties":{"$ref":"#/$defs/ExecutableChoiceOption"}}
[oneOf 2].options[key]ExecutableChoiceOption構造と有効な値は、型とスキーマを参照してください。
[oneOf 2].whenEmptyExecutableEmptyChoice · 必須選べる回答が一つもない場合の動作。
[oneOf 3].idId · 必須安定したID;表示名はキーではありません。
[oneOf 3].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 3].kind"branch" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 3].conditionExecutableCondition · 必須分岐や選択肢の有効化の前に評価する条件。
[oneOf 3].whenTrueExecutableContinuation · 必須条件が真の場合の進行先。
[oneOf 3].whenFalseExecutableContinuation · 必須条件が偽の場合の進行先。
[oneOf 4].idId · 必須安定したID;表示名はキーではありません。
[oneOf 4].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 4].kind"action" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 4].effectsArray<ExecutableEffect> · 必須アクションノードが順番に適用する状態の変更。
[oneOf 4].continuationExecutableContinuation · 必須ノードの処理が完了した後の進行先。
[oneOf 5].idId · 必須安定したID;表示名はキーではありません。
[oneOf 5].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 5].kind"command" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 5].commandRefId · 必須実行するゲームコマンドのID。
[oneOf 5].argumentsobject · 必須呼び出しに渡す、名前付きの引数値。
{"additionalProperties":{"$ref":"#/$defs/ExecutableOperand"}}
[oneOf 5].arguments[key]ExecutableOperand構造と有効な値は、型とスキーマを参照してください。
[oneOf 5].outcomesobject · 必須コマンドが返し得る結果の名前と、そのデータ契約およびバインディング。
{"additionalProperties":{"$ref":"#/$defs/ExecutableOutcomeBinding"}}
[oneOf 5].outcomes[key]ExecutableOutcomeBinding構造と有効な値は、型とスキーマを参照してください。
[oneOf 6].idId · 必須安定したID;表示名はキーではありません。
[oneOf 6].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 6].kind"jump" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 6].targetEntryRef · 必須変数や開始地点などを指す型付き参照。正確な構造は各形式を参照してください。
[oneOf 7].idId · 必須安定したID;表示名はキーではありません。
[oneOf 7].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 7].kind"end" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 8].idId · 必須安定したID;表示名はキーではありません。
[oneOf 8].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 8].kind"call" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 8].targetEntryRef · 必須変数や開始地点などを指す型付き参照。正確な構造は各形式を参照してください。
[oneOf 8].continuationExecutableContinuation · 必須ノードの処理が完了した後の進行先。
[oneOf 9].idId · 必須安定したID;表示名はキーではありません。
[oneOf 9].flowRefId · 必須シーン／サブストーリーのID。
[oneOf 9].kind"return" · 必須有効なデータ形式を選ぶ識別フィールド。
Schema · ExecutableNode
{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "dialogue"
        },
        "text": {
          "$ref": "#/$defs/ExecutableTextUse"
        },
        "speakerRef": {
          "$ref": "#/$defs/Id"
        },
        "emotionRef": {
          "$ref": "#/$defs/Id"
        },
        "continuation": {
          "$ref": "#/$defs/ExecutableContinuation"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind",
        "text",
        "continuation"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "choice"
        },
        "optionOrder": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/Id"
          },
          "uniqueItems": true
        },
        "options": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ExecutableChoiceOption"
          }
        },
        "whenEmpty": {
          "$ref": "#/$defs/ExecutableEmptyChoice"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind",
        "optionOrder",
        "options",
        "whenEmpty"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "branch"
        },
        "condition": {
          "$ref": "#/$defs/ExecutableCondition"
        },
        "whenTrue": {
          "$ref": "#/$defs/ExecutableContinuation"
        },
        "whenFalse": {
          "$ref": "#/$defs/ExecutableContinuation"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind",
        "condition",
        "whenTrue",
        "whenFalse"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "action"
        },
        "effects": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/ExecutableEffect"
          }
        },
        "continuation": {
          "$ref": "#/$defs/ExecutableContinuation"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind",
        "effects",
        "continuation"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "command"
        },
        "commandRef": {
          "$ref": "#/$defs/Id"
        },
        "arguments": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ExecutableOperand"
          }
        },
        "outcomes": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ExecutableOutcomeBinding"
          }
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind",
        "commandRef",
        "arguments",
        "outcomes"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "jump"
        },
        "target": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind",
        "target"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "end"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "call"
        },
        "target": {
          "$ref": "#/$defs/EntryRef"
        },
        "continuation": {
          "$ref": "#/$defs/ExecutableContinuation"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind",
        "target",
        "continuation"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "$ref": "#/$defs/Id"
        },
        "flowRef": {
          "$ref": "#/$defs/Id"
        },
        "kind": {
          "const": "return"
        }
      },
      "required": [
        "id",
        "flowRef",
        "kind"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ExecutableNode"
}

ExecutableOperand

フィールド型／必須意味／ルール
[oneOf 1].kind"literal" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 1].valueTypedValue · 必須リテラル値;宣言されたタイプと一致しなければなりません。
[oneOf 2].kind"variable" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 2].variableRefId · 必須読み書きする変数の ID 。
Schema · ExecutableOperand
{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "literal"
        },
        "value": {
          "$ref": "#/$defs/TypedValue"
        }
      },
      "required": [
        "kind",
        "value"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "variable"
        },
        "variableRef": {
          "$ref": "#/$defs/Id"
        }
      },
      "required": [
        "kind",
        "variableRef"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ExecutableOperand"
}

ExecutableOutcomeBinding

フィールド型／必須意味／ルール
resultBindingsobject · 必須コマンド結果名 → 返された値の宛先変数。
{"additionalProperties":{"$ref":"#/$defs/Id"}}
resultBindings[key]Id構造と有効な値は、型とスキーマを参照してください。
continuationExecutableContinuation · 必須ノードの処理が完了した後の進行先。
Schema · ExecutableOutcomeBinding
{
  "type": "object",
  "properties": {
    "resultBindings": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/Id"
      }
    },
    "continuation": {
      "$ref": "#/$defs/ExecutableContinuation"
    }
  },
  "required": [
    "resultBindings",
    "continuation"
  ],
  "additionalProperties": false,
  "title": "ExecutableOutcomeBinding"
}

ExecutableStory

フィールド型／必須意味／ルール
format"vnle.story" · 必須このデータコンテナの正確なフォーマット識別子。
containerVersion1 · 必須物語のコンテナ形式のバージョンを示す整数。現在は1。
storyBuildIdHash · 必須正規化された実行データのSHA-256。コンテンツのみの変更では変わりません。
executionExecutionContract · 必須型が定義された実行データの契約。
contentobject · 必須実行データから分離された、言語と各種項目のデータ。
{"additionalProperties":false}
content.sourceLocaleLocale · 必須テキストとフォールバックのソースロケール。
content.localesArray<Locale> · 必須原文の言語を含む、宣言済みのエクスポート言語。
{"minItems":1}
content.fallbackPolicyFallbackPolicy · 必須現在はsource。翻訳がなければ原文を使用します。
content.textsobject · 必須テキストID → ソースメッセージ、プレースホルダー、メタデータ。
{"additionalProperties":{"$ref":"#/$defs/ContentTextEntry"}}
content.texts[key]ContentTextEntry構造と有効な値は、型とスキーマを参照してください。
content.translationsobject · 必須言語 → テキストID → 翻訳。項目がなければ原文を使用します。
{"additionalProperties":{"type":"object","propertyNames":{"pattern":"^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"},"additionalProperties":{"$ref":"#/$defs/Translation"},"minProperties":1}}
content.translations[key]object構造と有効な値は、型とスキーマを参照してください。
content.charactersobject · 必須キャラクターID→ローカライズされた名前と感情を持つキャラクター。
{"additionalProperties":{"$ref":"#/$defs/ContentCharacter"}}
content.characters[key]ContentCharacter構造と有効な値は、型とスキーマを参照してください。
content.questsobject · 必須クエストID → 目標を含むクエストの定義。
{"additionalProperties":{"$ref":"#/$defs/ContentQuestDefinition"}}
content.quests[key]ContentQuestDefinition構造と有効な値は、型とスキーマを参照してください。
content.itemsobject · 必須アイテムID → アイテムの定義。
{"additionalProperties":{"$ref":"#/$defs/ContentItemDefinition"}}
content.items[key]ContentItemDefinition構造と有効な値は、型とスキーマを参照してください。
content.locationsobject · 必須場所ID → 場所の定義。
{"additionalProperties":{"$ref":"#/$defs/ContentLocationDefinition"}}
content.locations[key]ContentLocationDefinition構造と有効な値は、型とスキーマを参照してください。
content.minigamesobject · 必須ミニゲームID → 定義。ゲームの動作は呼び出し側で実装します。
{"additionalProperties":{"$ref":"#/$defs/ContentMinigameDefinition"}}
content.minigames[key]ContentMinigameDefinition構造と有効な値は、型とスキーマを参照してください。
content.assetsobject · 必須アセットID → メディアの定義。汎用エクスポートでは、エンジンで利用するアセットの解決結果は提供されません。
{"additionalProperties":{"$ref":"#/$defs/ContentAsset"}}
content.assets[key]ContentAsset構造と有効な値は、型とスキーマを参照してください。
content.variableDefinitionsobject · 必須名前とテキスト参照を含む、作成者が定義した変数。
{"additionalProperties":{"$ref":"#/$defs/ContentVariableDefinition"}}
content.variableDefinitions[key]ContentVariableDefinition構造と有効な値は、型とスキーマを参照してください。
content.commandDefinitionsobject · 必須テキスト参照を含む、作成者が定義したコマンド。
{"additionalProperties":{"$ref":"#/$defs/ContentCommandDefinition"}}
content.commandDefinitions[key]ContentCommandDefinition構造と有効な値は、型とスキーマを参照してください。
Schema · ExecutableStory
{
  "type": "object",
  "properties": {
    "format": {
      "const": "vnle.story"
    },
    "containerVersion": {
      "const": 1
    },
    "storyBuildId": {
      "$ref": "#/$defs/Hash"
    },
    "execution": {
      "$ref": "#/$defs/ExecutionContract"
    },
    "content": {
      "type": "object",
      "properties": {
        "sourceLocale": {
          "$ref": "#/$defs/Locale"
        },
        "locales": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/Locale"
          },
          "minItems": 1,
          "uniqueItems": true
        },
        "fallbackPolicy": {
          "$ref": "#/$defs/FallbackPolicy"
        },
        "texts": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentTextEntry"
          }
        },
        "translations": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$"
          },
          "additionalProperties": {
            "type": "object",
            "propertyNames": {
              "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
            },
            "additionalProperties": {
              "$ref": "#/$defs/Translation"
            },
            "minProperties": 1
          }
        },
        "characters": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentCharacter"
          }
        },
        "quests": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentQuestDefinition"
          }
        },
        "items": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentItemDefinition"
          }
        },
        "locations": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentLocationDefinition"
          }
        },
        "minigames": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentMinigameDefinition"
          }
        },
        "assets": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentAsset"
          }
        },
        "variableDefinitions": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentVariableDefinition"
          }
        },
        "commandDefinitions": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/ContentCommandDefinition"
          }
        }
      },
      "required": [
        "sourceLocale",
        "locales",
        "fallbackPolicy",
        "texts",
        "translations",
        "characters",
        "quests",
        "items",
        "locations",
        "minigames",
        "assets",
        "variableDefinitions",
        "commandDefinitions"
      ],
      "additionalProperties": false
    }
  },
  "required": [
    "format",
    "containerVersion",
    "storyBuildId",
    "execution",
    "content"
  ],
  "additionalProperties": false,
  "title": "ExecutableStory"
}

ExecutableTextUse

フィールド型／必須意味／ルール
textRefId · 必須content.textsと、そのテキストの契約への参照。
bindingsobject · 必須プレースホルダー／パラメーター名 → 型付きオペランド。
{"additionalProperties":{"$ref":"#/$defs/ExecutableOperand"}}
bindings[key]ExecutableOperand構造と有効な値は、型とスキーマを参照してください。
Schema · ExecutableTextUse
{
  "type": "object",
  "properties": {
    "textRef": {
      "$ref": "#/$defs/Id"
    },
    "bindings": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/ExecutableOperand"
      }
    }
  },
  "required": [
    "textRef",
    "bindings"
  ],
  "additionalProperties": false,
  "title": "ExecutableTextUse"
}

ExecutionContract

フィールド型／必須意味／ルール
format"vnle.execution" · 必須このデータコンテナの正確なフォーマット識別子。
contractVersionRuntimeVersion · 必須実行互換性バージョン:メジャーとマイナー。
projectIdId · 必須ソースプロジェクトの安定したID。
requiredCapabilitiesArray<Capability> · 必須完全な実行アダプターが開始前に確認すべき機能。
limitsobject · 必須自動実行と再帰の上限。
{"additionalProperties":false}
limits.maxAutomaticTransitions1000 · 必須ユーザー入力を待たずに自動で進める回数の上限。
limits.maxConditionDepth32 · 必須条件の入れ子の深さの上限。
limits.maxConditionTerms1024 · 必須条件項目数の上限。
limits.maxCallDepth32 · 必須サブストーリー呼び出しの入れ子の深さの上限。
entriesobject · 必須エントリーID→フローとノード参照。
{"additionalProperties":{"$ref":"#/$defs/RuntimeEntry"}}
entries[key]RuntimeEntry構造と有効な値は、型とスキーマを参照してください。
nodesobject · 必須ノードID → 実行可能なノード。kindでフィールドが決まります。
{"additionalProperties":{"$ref":"#/$defs/ExecutableNode"}}
nodes[key]ExecutableNode構造と有効な値は、型とスキーマを参照してください。
variablesobject · 必須変数ID → 実行時の型付き変数の定義。
{"additionalProperties":{"$ref":"#/$defs/RuntimeVariable"}}
variables[key]RuntimeVariable構造と有効な値は、型とスキーマを参照してください。
commandsobject · 必須コマンドID → 実行時の型付きシグネチャ。
{"additionalProperties":{"$ref":"#/$defs/RuntimeSignature"}}
commands[key]RuntimeSignature構造と有効な値は、型とスキーマを参照してください。
textContractsobject · 必須テキストID → 実行に必要なプレースホルダー契約。
{"additionalProperties":{"$ref":"#/$defs/PlaceholderContract"}}
textContracts[key]PlaceholderContract構造と有効な値は、型とスキーマを参照してください。
Schema · ExecutionContract
{
  "type": "object",
  "properties": {
    "format": {
      "const": "vnle.execution"
    },
    "contractVersion": {
      "$ref": "#/$defs/RuntimeVersion"
    },
    "projectId": {
      "$ref": "#/$defs/Id"
    },
    "requiredCapabilities": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/Capability"
      },
      "uniqueItems": true
    },
    "limits": {
      "type": "object",
      "properties": {
        "maxAutomaticTransitions": {
          "const": 1000
        },
        "maxConditionDepth": {
          "const": 32
        },
        "maxConditionTerms": {
          "const": 1024
        },
        "maxCallDepth": {
          "const": 32
        }
      },
      "required": [
        "maxAutomaticTransitions",
        "maxConditionDepth",
        "maxConditionTerms",
        "maxCallDepth"
      ],
      "additionalProperties": false
    },
    "entries": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/RuntimeEntry"
      }
    },
    "nodes": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/ExecutableNode"
      }
    },
    "variables": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/RuntimeVariable"
      }
    },
    "commands": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/RuntimeSignature"
      }
    },
    "textContracts": {
      "type": "object",
      "propertyNames": {
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "additionalProperties": {
        "$ref": "#/$defs/PlaceholderContract"
      }
    }
  },
  "required": [
    "format",
    "contractVersion",
    "projectId",
    "requiredCapabilities",
    "limits",
    "entries",
    "nodes",
    "variables",
    "commands",
    "textContracts"
  ],
  "additionalProperties": false,
  "title": "ExecutionContract"
}

FallbackPolicy

フィールド型／必須意味／ルール
Schema · FallbackPolicy
{
  "type": "string",
  "enum": [
    "block",
    "source"
  ],
  "title": "FallbackPolicy"
}

Hash

フィールド型／必須意味／ルール
Schema · Hash
{
  "type": "string",
  "pattern": "^sha256:[0-9a-f]{64}$",
  "title": "Hash"
}

Id

フィールド型／必須意味／ルール
Schema · Id
{
  "type": "string",
  "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$",
  "title": "Id"
}

Key

フィールド型／必須意味／ルール
Schema · Key
{
  "type": "string",
  "pattern": "^[A-Za-z][A-Za-z0-9_.-]{0,127}$",
  "title": "Key"
}

Locale

フィールド型／必須意味／ルール
Schema · Locale
{
  "type": "string",
  "pattern": "^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$",
  "title": "Locale"
}

メッセージ

フィールド型／必須意味／ルール
kind"segments" · 必須有効なデータ形式を選ぶ識別フィールド。
segmentsArray<object | object> · 必須順番に並んだテキストとプレースホルダーのセグメント。
Schema · Message
{
  "type": "object",
  "properties": {
    "kind": {
      "const": "segments"
    },
    "segments": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "kind": {
                "const": "text"
              },
              "text": {
                "type": "string"
              }
            },
            "required": [
              "kind",
              "text"
            ],
            "additionalProperties": false
          },
          {
            "type": "object",
            "properties": {
              "kind": {
                "const": "placeholder"
              },
              "placeholderRef": {
                "$ref": "#/$defs/Id"
              }
            },
            "required": [
              "kind",
              "placeholderRef"
            ],
            "additionalProperties": false
          }
        ]
      }
    }
  },
  "required": [
    "kind",
    "segments"
  ],
  "additionalProperties": false,
  "title": "Message"
}

OutcomeDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
resultsArray<ResultDefinition> · 必須各結果が返す、名前と型を持つ値。
Schema · OutcomeDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/ResultDefinition"
      }
    }
  },
  "required": [
    "id",
    "name",
    "results"
  ],
  "additionalProperties": false,
  "title": "OutcomeDefinition"
}

ParameterDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
valueTypeValueType · 必須想定される値のデータ契約。使用可能なエンティティの型を含みます。
defaultValueTypedValue型を持つ初期値／既定値。
Schema · ParameterDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "valueType": {
      "$ref": "#/$defs/ValueType"
    },
    "defaultValue": {
      "$ref": "#/$defs/TypedValue"
    }
  },
  "required": [
    "id",
    "name",
    "valueType"
  ],
  "additionalProperties": false,
  "title": "ParameterDefinition"
}

PlaceholderContract

フィールド型／必須意味／ルール
map[key]ScalarType構造と有効な値は、型とスキーマを参照してください。
Schema · PlaceholderContract
{
  "type": "object",
  "propertyNames": {
    "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
  },
  "additionalProperties": {
    "$ref": "#/$defs/ScalarType"
  },
  "title": "PlaceholderContract"
}

PlaceholderDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
displayNamestring · 必須人が読み取れるアセットの表示名。
valueTypeScalarType · 必須想定される値のデータ契約。使用可能なエンティティの型を含みます。
Schema · PlaceholderDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "displayName": {
      "type": "string"
    },
    "valueType": {
      "$ref": "#/$defs/ScalarType"
    }
  },
  "required": [
    "id",
    "displayName",
    "valueType"
  ],
  "additionalProperties": false,
  "title": "PlaceholderDefinition"
}

QuestObjective

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
labelTextRefId · 必須ローカライズされたラベルのテキストID。
descriptionTextRefId翻訳可能な説明文のテキストID。
Schema · QuestObjective
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "labelTextRef": {
      "$ref": "#/$defs/Id"
    },
    "descriptionTextRef": {
      "$ref": "#/$defs/Id"
    }
  },
  "required": [
    "id",
    "labelTextRef"
  ],
  "additionalProperties": false,
  "title": "QuestObjective"
}

RelativePath

フィールド型／必須意味／ルール
Schema · RelativePath
{
  "type": "string",
  "minLength": 1,
  "maxLength": 1024,
  "title": "RelativePath"
}

ResultDefinition

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
namestring · 必須作成者が付けた名前。参照キーとして使用しないでください。
valueTypeValueType · 必須想定される値のデータ契約。使用可能なエンティティの型を含みます。
Schema · ResultDefinition
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "name": {
      "type": "string"
    },
    "valueType": {
      "$ref": "#/$defs/ValueType"
    }
  },
  "required": [
    "id",
    "name",
    "valueType"
  ],
  "additionalProperties": false,
  "title": "ResultDefinition"
}

RuntimeEntry

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
flowRefId · 必須シーン／サブストーリーのID。
nodeRefId · 必須次の実行可能ノードID。
Schema · RuntimeEntry
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "flowRef": {
      "$ref": "#/$defs/Id"
    },
    "nodeRef": {
      "$ref": "#/$defs/Id"
    }
  },
  "required": [
    "id",
    "flowRef",
    "nodeRef"
  ],
  "additionalProperties": false,
  "title": "RuntimeEntry"
}

RuntimeSignature

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
inputsArray<object> · 必須名前と型を持つシグネチャの入力項目。
outcomesArray<object> · 必須コマンドが返し得る結果の名前と、そのデータ契約およびバインディング。
{"minItems":1}
Schema · RuntimeSignature
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "inputs": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/$defs/Id"
          },
          "valueType": {
            "$ref": "#/$defs/ValueType"
          },
          "defaultValue": {
            "$ref": "#/$defs/TypedValue"
          }
        },
        "required": [
          "id",
          "valueType"
        ],
        "additionalProperties": false
      }
    },
    "outcomes": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/$defs/Id"
          },
          "results": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "$ref": "#/$defs/Id"
                },
                "valueType": {
                  "$ref": "#/$defs/ValueType"
                }
              },
              "required": [
                "id",
                "valueType"
              ],
              "additionalProperties": false
            }
          }
        },
        "required": [
          "id",
          "results"
        ],
        "additionalProperties": false
      },
      "minItems": 1
    }
  },
  "required": [
    "id",
    "inputs",
    "outcomes"
  ],
  "additionalProperties": false,
  "title": "RuntimeSignature"
}

RuntimeVariable

フィールド型／必須意味／ルール
idId · 必須安定したID;表示名はキーではありません。
valueTypeScalarType · 必須想定される値のデータ契約。使用可能なエンティティの型を含みます。
defaultValueScalarValue · 必須型を持つ初期値／既定値。
Schema · RuntimeVariable
{
  "type": "object",
  "properties": {
    "id": {
      "$ref": "#/$defs/Id"
    },
    "valueType": {
      "$ref": "#/$defs/ScalarType"
    },
    "defaultValue": {
      "$ref": "#/$defs/ScalarValue"
    }
  },
  "required": [
    "id",
    "valueType",
    "defaultValue"
  ],
  "additionalProperties": false,
  "title": "RuntimeVariable"
}

RuntimeVersion

フィールド型／必須意味／ルール
major1 · 必須互換性のないメジャーバージョン。サポートされていないバージョンを拒否します。
minor1 · 必須メジャーバージョン内の拡張バージョン。
Schema · RuntimeVersion
{
  "type": "object",
  "properties": {
    "major": {
      "const": 1
    },
    "minor": {
      "const": 1
    }
  },
  "required": [
    "major",
    "minor"
  ],
  "additionalProperties": false,
  "title": "RuntimeVersion"
}

ScalarType

フィールド型／必須意味／ルール
Schema · ScalarType
{
  "type": "string",
  "enum": [
    "boolean",
    "integer",
    "string"
  ],
  "title": "ScalarType"
}

ScalarValue

フィールド型／必須意味／ルール
[oneOf 1].type"boolean" · 必須型を識別するフィールド。使用できる値は周囲のスキーマによって決まります。
[oneOf 1].valueboolean · 必須リテラル値;宣言されたタイプと一致しなければなりません。
[oneOf 2].type"integer" · 必須型を識別するフィールド。使用できる値は周囲のスキーマによって決まります。
[oneOf 2].valueinteger · 必須リテラル値;宣言されたタイプと一致しなければなりません。
{"minimum":-2147483648,"maximum":2147483647}
[oneOf 3].type"string" · 必須型を識別するフィールド。使用できる値は周囲のスキーマによって決まります。
[oneOf 3].valuestring · 必須リテラル値;宣言されたタイプと一致しなければなりません。
Schema · ScalarValue
{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "type": {
          "const": "boolean"
        },
        "value": {
          "type": "boolean"
        }
      },
      "required": [
        "type",
        "value"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "type": {
          "const": "integer"
        },
        "value": {
          "type": "integer",
          "minimum": -2147483648,
          "maximum": 2147483647
        }
      },
      "required": [
        "type",
        "value"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "type": {
          "const": "string"
        },
        "value": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "value"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ScalarValue"
}

Translation

フィールド型／必須意味／ルール
textRefId · 必須content.textsと、そのテキストの契約への参照。
localeLocale · 必須この翻訳エントリのロケールコード。
messageメッセージ · 必須プレースホルダーの契約に従った翻訳文。
allowEmptyboolean · 必須意図的に空にした翻訳を許可します。
workflowStatus"draft" | "translated" | "reviewed" · 必須翻訳作業の状態。実行時の分岐ではありません。
basedOnSourceFingerprintHash · 必須翻訳の基準となった原文。不一致なら原文の更新後に未確認の翻訳です。
reviewedContextFingerprintHashレビューされた翻訳状態のコンテキストフィンガープリント。
origin"ai"構造と有効な値は、型とスキーマを参照してください。
Schema · Translation
{
  "type": "object",
  "properties": {
    "textRef": {
      "$ref": "#/$defs/Id"
    },
    "locale": {
      "$ref": "#/$defs/Locale"
    },
    "message": {
      "$ref": "#/$defs/Message"
    },
    "allowEmpty": {
      "type": "boolean"
    },
    "workflowStatus": {
      "type": "string",
      "enum": [
        "draft",
        "translated",
        "reviewed"
      ]
    },
    "basedOnSourceFingerprint": {
      "$ref": "#/$defs/Hash"
    },
    "reviewedContextFingerprint": {
      "$ref": "#/$defs/Hash"
    },
    "origin": {
      "const": "ai"
    }
  },
  "required": [
    "textRef",
    "locale",
    "message",
    "allowEmpty",
    "workflowStatus",
    "basedOnSourceFingerprint"
  ],
  "additionalProperties": false,
  "title": "Translation"
}

TypedValue

フィールド型／必須意味／ルール
[oneOf 2].type"reference" · 必須型を識別するフィールド。使用できる値は周囲のスキーマによって決まります。
[oneOf 2].entityTypeEntityType · 必須エンティティ参照のカタログ種別。
[oneOf 2].valueId · 必須リテラル値;宣言されたタイプと一致しなければなりません。
Schema · TypedValue
{
  "oneOf": [
    {
      "$ref": "#/$defs/ScalarValue"
    },
    {
      "type": "object",
      "properties": {
        "type": {
          "const": "reference"
        },
        "entityType": {
          "$ref": "#/$defs/EntityType"
        },
        "value": {
          "$ref": "#/$defs/Id"
        }
      },
      "required": [
        "type",
        "entityType",
        "value"
      ],
      "additionalProperties": false
    }
  ],
  "title": "TypedValue"
}

ValueType

フィールド型／必須意味／ルール
[oneOf 2].kind"reference" · 必須有効なデータ形式を選ぶ識別フィールド。
[oneOf 2].entityTypeEntityType · 必須エンティティ参照のカタログ種別。
Schema · ValueType
{
  "oneOf": [
    {
      "$ref": "#/$defs/ScalarType"
    },
    {
      "type": "object",
      "properties": {
        "kind": {
          "const": "reference"
        },
        "entityType": {
          "$ref": "#/$defs/EntityType"
        }
      },
      "required": [
        "kind",
        "entityType"
      ],
      "additionalProperties": false
    }
  ],
  "title": "ValueType"
}