diff --git a/onboarding/ja-jp/ja-as-cicd.md b/onboarding/ja-jp/ja-as-cicd.md
new file mode 100644
index 0000000..a6353f1
--- /dev/null
+++ b/onboarding/ja-jp/ja-as-cicd.md
@@ -0,0 +1,10 @@
+---
+uid: as-cicd
+title: Analysis Services CI/CD with Azure DevOps and Tabular Editor
+author: Daniel Otykier
+updated: 2021-10-04
+---
+
+# Analysis Services CI/CD with Azure DevOps and Tabular Editor
+
+(WIP)
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-boosting-productivity-te3.md b/onboarding/ja-jp/ja-boosting-productivity-te3.md
new file mode 100644
index 0000000..b5d905b
--- /dev/null
+++ b/onboarding/ja-jp/ja-boosting-productivity-te3.md
@@ -0,0 +1,15 @@
+# Tabular Editor 3で生産性を向上させる
+
+
+
+このセクションでは、Tabular Editor 3とその主な機能に素早く慣れることができるよう、もっとも生産的な方法で何かを成し遂げる方法に重点を置いた記事を多数掲載しています。
+
+以下は記事の概要と、それぞれの記事で学べることです。
+
+- [テーブルのインポートとデータモデリング](ja-importing-tables-data-modeling.md)：この記事では、テーブルのインポート、テーブルスキーマの更新、リレーションシップの可視化と編集の方法について説明します。
+- [リフレッシュ・プレビュー・クエリ](ja-refresh-preview-query.md)：この記事では、リフレッシュのスケジュールを設定する方法について説明します。この記事では、リフレッシュ操作をスケジュールする方法、テーブルデータをプレビューする方法、ピボットグリッドを使用して要約されたデータを表示する方法、DAXクエリーを作成および実行する方法、Tabular Editor 3の統合版である [VertiPaq Analyzer](https://www.sqlbi.com/tools/vertipaq-analyzer/) を使用する方法について説明しています。
+- [creating-and-testing-dax](ja-creating-and-testing-dax.md)：この記事では、Tabular Editor 3の強力なDAXエディターを紹介し、メジャー、計算列、計算テーブルなどのDAX計算をモデルにすばやく追加および編集する方法を示します。
+- [dax-script-introduction](ja-creating-and-testing-dax.md)：この記事では、DAXスクリプト機能を使用して、複数のメジャーの定義を1つのDAXスクリプトにまとめ複雑なビジネス・ロジックを記述、維持、およびテストする方法を説明します。
+- [bpa](ja-bpa.md): この記事では、ベストプラクティス・アナライザーの詳細と、カスタマイズ可能なベストプラクティスルールを設定し、モデルのコード品質を向上させる方法について説明します。
+- [cs-scripts-and-macros](ja-cs-scripts-and-macros.md)：この記事では、Tabular Editor 3におけるC#スクリプトの概念、スクリプトレコーダー、およびUIに統合可能な再利用可能マクロとしてスクリプトを保存する方法について紹介します。
+- [パーソナライジング-TE3](ja-personalizing-te3.md)：この記事では、Tabular Editor 3で利用できる幅広い設定オプションとプリファレンスを紹介し、ツールをニーズに合わせて調整できるようにします。
diff --git a/onboarding/ja-jp/ja-bpa.md b/onboarding/ja-jp/ja-bpa.md
new file mode 100644
index 0000000..6b5b531
--- /dev/null
+++ b/onboarding/ja-jp/ja-bpa.md
@@ -0,0 +1,104 @@
+# ベストプラクティスアナライザーでコード品質を向上させる
+
+ここまでで、Tabular Object Model（TOM）が比較的複雑なデータ構造であり、多くの異なるタイプのオブジェクトとプロパティを持つことはすでにご存じでしょう。これらのプロパティに割り当てるべき最適な値は必ずしも明確でなく、多くの場合、特定のユースケースやモデル設計に依存します。Tabular Editorの**Best Practice Analyzer**はTOMを継続的にスキャンし、定義可能なベストプラクティスルールに違反がないかどうかを調べます。これにより、オブジェクトのプロパティが常に理想的な値に設定されているかどうかを確認できます。
+
+ベストプラクティス・アナライザーで確認できること。
+
+- **DAX式** 特定のDAX関数または構成要素が使用されたときに警告するルールを作成します。
+- **書式設定** 書式文字列や説明などを指定するよう促すルールを作成します。
+- **命名規則** 特定のタイプのオブジェクト（キー列、隠し列など）が特定の名前パターンにしたがっているかどうかをチェックするルールを作成します。
+- **パフォーマンス** 計算列の数を減らすことを推奨するなど、モデルのパフォーマンスに関連するさまざまな側面をチェックするルールを作成します。
+
+Best Practice Analyzerは、モデルの完全なメタデータにアクセスでき、より高度なシナリオのためにVertiPaq Analyzerの統計にもアクセスできます。
+
+> [!NOTE]。
+> Tabular EditorにはBPAルールが付属していません。最初に独自のルールを定義するか、[Power BI CAT Team が推奨するルール](https://powerbi.microsoft.com/en-ca/blog/best-practice-rules-to-improve-your-models-performance/) のような標準的なルールセットを使用する必要があります。
+
+## ベストプラクティスルールの管理
+
+モデルに適用するルールを追加、削除、または修正するには、「ツール > BPAルールの管理...」メニュー オプションを使用します。
+
+
+
+このUIには2つのリストがあります。一番上のリストは、現在ロードされているルールの**コレクション**を表します。このリストでコレクションを選択すると、そのコレクション内で定義されているすべてのルールが下のリストに表示されます。モデルがロードされると、以下の3つのルール・コレクションが表示されます。
+
+* **現在のモデル内のルール** **Rules within the current model**: 名前が示すように、これは、現在のモデル内で定義されたルールのコレクションです。ルール定義は、Modelオブジェクトのアノテーションとして保存されます。
+* **ローカルユーザーのルール** **Rules for local user**: これらは `%LocalAppData%TabularEditor3 FilterBPARules.json` ファイルに格納されているルールです。これらのルールは、現在ログインしているWindowsユーザーがTabular Editorにロードするすべてのモデルに適用されます。
+* **Rules on the local machine**: これらのルールは `%ProgramData%TabularEditorTabularPARules.json` に格納されます。これらのルールは、現在のマシンでTabular Editorにロードされるすべてのモデルに適用されます。
+
+同じルール（IDによる）が複数のコレクションにある場合、優先順位は上から下になります。つまり、モデル内で定義されたルールは、ローカルマシンで定義された同じIDのルールよりも優先されます。これにより、たとえば、モデル特有の慣習を考慮に入れて、既存のルールを上書きできます。
+
+リストの上部には、**(Effective rules)**という特別なコレクションが表示されます。このコレクションを選択すると、現在ロードされているモデルに実際に適用されるルールのリストが表示され、前述のように、同一のIDを持つルールの優先順位が尊重されます。下のリストには、ルールがどのコレクションに属しているかが表示されます。また、より高い優先順位のコレクションに同じIDのルールが存在する場合、そのルールの名前は打ち消されることに注意してください。
+
+
+
+## コレクションの追加
+
+ルールコレクションは、特定のモデルに追加できます。ネットワーク共有にルールファイルがある場合、そのファイルをルールコレクションとして現在のモデルに含めることができます。ファイルの場所への書き込み権限があれば、そのファイルからルールを追加/変更/削除することもできます。この方法で追加されたルール・コレクションは、モデル内で定義されたルールよりも優先されます。このようなコレクションを複数追加した場合、それらを上下に移動して、相互の優先順位を制御できます。
+
+「追加...」ボタンをクリックすると、新しいルール・コレクションをモデルに追加できます。これには、以下のオプションがあります。
+
+
+
+* **Create new Rule File** **Create new Rule File**: 指定された場所に新しい空の .jsonファイルが作成され、その後ルールを追加できます。ファイルを選択する際、相対的なファイルパスを使用するオプションがあることに注意してください。これは、現在のモデルと同じコードリポジトリにルールファイルを保存したい場合に便利です。ただし、相対的なルール・ファイルの参照は、モデルがディスクからロードされたときにのみ機能することに注意してください（Analysis Servicesのインスタンスからモデルをロードするときには作業ディレクトリが存在しないため）。
+* **ローカル・ルール・ファイルを含める** **Include local Rule File**: ルールを含む .jsonファイルをすでに持っていて、それをモデルに含めたい場合はこのオプションを使用します。ここでも、相対ファイルパスを使用するオプションがあり、ファイルがモデルのメタデータへ近い場所にある場合は有効です。ファイルがネットワーク共有（または一般に、現在ロードされているモデル・メタデータが存在する場所とは異なるドライブ）にある場合、絶対パスを使用してのみインクルードできます。
+* **Include Rule File from URL**: このオプションでは、有効なルールセット（json形式）を返すHTTP/HTTPS URLを指定できます。これは、オンラインソースのルール、たとえば [BestPracticeRules GitHub サイト](https://github.com/TabularEditor/BestPracticeRules) の [標準 BPA ルール](https://raw.githubusercontent.com/TabularEditor/BestPracticeRules/master/BPARules-standard.json) を含めたい場合に便利です。オンラインソースから追加されたルールコレクションは、読み取り専用になります。
+
+## コレクション内のルールを修正する
+
+画面の下部では、現在選択されているコレクション内のルールを追加、編集、クローン、削除できます（コレクションが保存されている場所への書き込み権限がある場合）。さらに、"Move to... "ボタンを使用すると、選択したルールを別のコレクションに移動またはコピーすることができ、複数のルールのコレクションを簡単に管理できます。
+
+## ルールの追加
+
+コレクションに新しいルールを追加するには、**New rule...**ボタンをクリックします。これにより、ベストプラクティスルールエディターが表示されます（以下のスクリーンショットを参照）。
+
+
+
+新しいルールを作成する場合、以下の詳細を指定する必要があります。
+
+- **名前**: ルールの名前。Tabular Editorのユーザーに表示されます。
+- **ID**：ルールの内部ID。ルールの内部ID。ルールコレクション内で一意である必要があります。異なるコレクション間で複数のルールが同じIDを持つ場合、最も優先順位の高いコレクション内のルールのみが適用されます。
+- 重要度**。厳しさはTabular EditorのUIでは使用されませんが、[Tabular Editorのコマンドラインインターフェース](xref:command-line-options)でベストプラクティス分析を実行する場合、ルール違反がどのくらい「厳しい」かをこの数値で決定します。
+ - 1 = 情報のみ
+ - 2 = 警告
+ - 3（またはそれ以上）= エラー
+- **カテゴリ**。ルールを論理的にグループ化し、ルール管理を容易にするため、使用されます。
+- **説明** (オプション): ルールの目的を説明するために使用します。ベストプラクティス・アナライザーのビューにツールチップとして表示されます。説明フィールドでは、以下のプレースホルダー値を使用して、より文脈に沿ったメッセージを提供できます。
+ - object%` は、現在のオブジェクトへの完全修飾されたDAXリファレンスを返します（該当する場合）。
+ - objectname%` は、現在のオブジェクトの名前のみを返します。
+ - objecttype%` は現在のオブジェクトのタイプを返します。
+- **Applies to**: ルールを適用するオブジェクトの種類を選択します。
+- **Expression**: Dynamic LINQ](https://dynamic-linq.net/expression-language) 検索式を入力します。（**Applies to** ドロップダウンで選択したオブジェクト タイプのうち）ルールに違反するオブジェクトに対して `true` と評価されるはずの式です。Dynamic LINQ式は、選択されたオブジェクトタイプで利用可能なTOMプロパティだけでなく、幅広い標準.NETメソッドとプロパティにアクセスできます。
+- **最小限の互換性レベル**。一部のTOMプロパティは、すべての互換性レベルでは使用できません。汎用ルールを作成する場合は、このドロップダウンを使用して、ルールが適用されるべきモデルの最小互換性レベルを指定します。
+
+ルールがディスク上のルールコレクションに保存されると、上記のすべてのプロパティが JSON 形式で保存されます。JSONファイルを編集することで、ルールの追加・編集・削除を行うことができます。また、ルールに `FixExpression` プロパティを指定することも可能です。これは、ルール違反修正するため、モデルに適用される[C#スクリプト](xref:cs-scripts-and-macros)を生成するために使用される文字列です。
+
+## ベストプラクティス・アナライザー・ビューの使用
+
+Tabular Editorは、ベストプラクティスルール違反を**Best Practice Analyzer**ビューに表示します。また、メインウィンドウの下部にあるステータスバーでルール違反の件数を確認できます。ビューにフォーカスを当てるには、**表示 > ベストプラクティス アナライザー** メニューオプションを使用するか、ステータスバーの「# BP issues」ボタンをクリックします。
+
+ベストプラクティス・アナライザー・ビュー](~/images/best-practice-analyzer-view.png)
+
+ベストプラクティス アナライザー ビュー**には、違反のオブジェクトを持つすべてのルールのリストが表示されます。各ルールの下には、違反しているオブジェクトのリストが表示されます。リスト内のオブジェクトをダブルクリックすると、**TOM Explorer**でそのオブジェクトに移動できます。
+
+
+
+オブジェクトを右クリックすると、上記のようないくつかのオプションが表示されます。これらは以下の通りです。
+
+- オブジェクトに移動する**。オブジェクトへ移動**：オブジェクトをダブルクリックして、**TOM Explorer**でそのオブジェクトに移動するのと同じです。
+- オブジェクトを無視する**。オブジェクトに注釈が追加され、ベストプラクティス・アナライザーがそのオブジェクトの特定のルールを無視するように指示します。無視されるルールはIDで指定します。
+- 修正スクリプトを生成する**。このオプションは、ルールに `FixExpression` プロパティが指定されている場合にのみ利用可能です。このオプションを選択すると、Tabular Editorは選択されたルールの `FixExpression` に基づいて新しいC#スクリプトを作成します。
+- **Apply fix**: このオプションは、ルールに `FixExpression` プロパティが指定されている場合にのみ利用可能です。このオプションを選択すると、Tabular Editorはルール違反を自動的に修正するために、選択されたルールの `FixExpression` を実行します。
+
+> [!注意]。
+> ベストプラクティス・アナライザーのビューでは、ShiftキーまたはCtrlキーを押しながらオブジェクトを複数選択することができます。
+
+上記のオプションは、**Best Practice Analyzerビュー**の上部にあるツールバーボタンとしても利用可能です。さらに、すべてのアイテムの拡大/縮小、無視されたルール/オブジェクトの表示、手動更新（バックグラウンドスキャンが無効な場合に必要、下記参照）を行うためのボタンも用意されています。
+
+## ベストプラクティス・アナライザーを無効にする
+
+場合によっては、ベストプラクティス・アナライザーのバックグラウンドスキャンを無効にできます。たとえば、評価に比較的長い時間のかかるルールがある場合や、非常に大きなモデルを扱っている場合などです。
+
+バックグラウンドスキャンは、**Tools > Preferences > Features > Best Practice Analyzer** で、**Scan for Best Practice violations in the background** のチェックを外して無効にできます。
+
+なお、バックグラウンドスキャンを無効にしていても、上記のように **Best Practice Analyzer ビュー** の **Refresh** ボタンを使って手動でスキャンを実行することは可能です。
diff --git a/onboarding/ja-jp/ja-creating-and-testing-dax.md b/onboarding/ja-jp/ja-creating-and-testing-dax.md
new file mode 100644
index 0000000..d886884
--- /dev/null
+++ b/onboarding/ja-jp/ja-creating-and-testing-dax.md
@@ -0,0 +1,113 @@
+# メジャーや他の計算オブジェクトを追加する
+
+Tabular Editor 2.xが2017年初頭にリリースされて以来、メジャー間のDAX式をすばやく修正する機能は、常にツールのもっとも人気のある機能でした。戻る/進むナビゲーション、コピー/ペースト操作、DAX依存性の視覚化、アンドゥ/リドゥのサポートと組み合わせて、このツールは常に、複数の小さな変更を素早く行う能力が重要である、大規模で複雑なデータモデルを扱う人にとって好ましい選択肢となってきました。
+
+この点で、Tabular Editor 2.xのユーザーからの唯一の不満は、DAXコードアシスト機能（時に「IntelliSense」と呼ばれる）がないことでした。とくにDAXに100％精通しているわけではない場合（そうである人はほとんどいません！）、DAXコードエディターが構文や関数パラメーターなどを覚えるのを助けてくれるのは非常に便利です。
+
+これはすべて、Tabular Editor 3にある新しいDAXコードエディターで対処されます。
+
+
+
+この資料では、メジャーおよびその他の計算オブジェクトを作成する方法、およびこれらのオブジェクトのDAX式を変更する方法について説明します。DAXコード・エディターの多くの機能の詳細については、 を参照してください。
+
+## メジャーの追加
+
+モデルに [いくつかのテーブルをインポート](ja-importing-tables-data-modeling.md) して [テーブル間のリレーションシップを作成](ja-importing-tables-data-modeling.md) したら、次はビジネス・ロジックを含むいくつかの明示的メジャーを追加する番です。
+
+> [!TIP］
+> 技術的には、Power BI レポートでデータを視覚化する前に、明示的なメジャーをモデルに追加する必要はありません。しかし、MDXベースのクライアントツール（ExcelやTabular Editor 3のPivot Gridなど）では明示的なメジャーが必要なため、常に追加しておくことがベストプラクティスです。また、[Calculation Groups](https://docs.microsoft.com/en-us/analysis-services/tabular-models/calculation-groups?view=asallproducts-allversions) は明示的なメジャーにのみ適用されます。
+
+Tabular Editorを使用して新しいメジャーを追加するには、メジャーを追加するテーブルを右クリックし、**Create > Measure** (ALT+1) を選択します。
+
+
+
+新しいメジャーを追加すると、そのメジャーの名前を編集できるようになります。メジャーの名前を入力したら、ENTERキーを押します。名前は後で**Properties**ビューで編集するか、**TOM Explorer**でメジャーを選択した状態でF2を押すと、いつでも編集できます。
+
+**Expression Editor** ビューは、メジャーのDAX式を指定するために使用されます。コードを入力すると、DAXエディターによってコードの候補が表示され、構文エラーや意味上のエラーが下線表示されることに注意してください。
+
+メジャーを追加する
+
+**Expression Editor** の左上隅にあるドロップダウン・ボックスは、現在選択されているオブジェクトのさまざまなDAXプロパティを切り替えるために使用されます。たとえば、Analysis Servicesの新しいバージョンでは、メジャーは[`Detail Rows Expression`](https://www.sqlbi.com/articles/controlling-drillthrough-in-excel-pivottables-connected-to-power-bi-or-analysis-services/)と同様に `Expression` プロパティを持っています。その他の種類のオブジェクトには、DAXコードを含むさまざまなプロパティがあります。たとえば、[KPI](https://docs.microsoft.com/en-us/analysis-services/tabular-models/kpis-ssas-tabular?view=asallproducts-allversions)には3つの異なるDAXプロパティがあります。Tabular EditorでKPIを追加するには、メジャーを右クリックし、**Create > KPI** を選択します。
+
+[KPIの編集](../../images/editing-kpis.png)を選択します。
+
+メジャーを非表示にする場合は、右クリックして、**Make invisible** (CTRL+I) オプションを選択するだけです。同様に、**Make visible** (CTRL+U) オプションを選択すると、メジャーを非表示にできます。
+
+## その他のメジャーのプロパティ
+
+`Name`, `Expression`, `Hidden` プロパティに加えて、**Properties** ビューを使用して、**TOM Explorer** で現在選択されているオブジェクトのすべてのプロパティの値を確認および編集できます。メジャーでは、たとえばここで `Format String` を設定できます。詳しくは、[プロパティビュー](xref:properties-view)を参照してください。
+
+## 計算されたカラムを追加する
+
+計算されたカラムを追加するには、カラムを追加したいテーブルを右クリックし、 **Create > Calculated Column** (ALT+2)を選択します。列の名前を付け、上記のメジャーの場合と同様に、**式エディター** を使用してそのDAX式を編集します。
+
+> [重要] このオプションはデフォルトでは使用できません。
+> Power BI Desktop モデルに接続している場合、このオプションはデフォルトでは使用できません。これは、[Power BI Desktop がサポートする外部ツールの制限](xref:desktop-limitations) に起因するものです。詳しくはリンクをクリックしてください。
+
+> [!注意]を参照してください。
+> 計算列の DAX 式が変更された場合、その列をレポートで使用するには、その列が存在するテーブルをリフレッシュする必要があります。詳しくは を参照してください。
+
+## 計算されたテーブルの追加
+
+計算テーブルを追加するには、モデルまたは "Tables"フォルダーを右クリックし、**Create > Calculated Table** (ALT+6)を選択します。テーブルに名前を付け、上記のメジャーの場合と同様に、**式エディター** を使用してそのDAX式を編集します。DAX式を変更すると、テーブルの列が自動的に変更されることに注意してください。他のDAX式がテーブルを参照する場合、または列が階層構造で使用される場合、これはカスケード効果を引き起こす可能性があります。
+
+> [!重要] このオプションはデフォルトでは使用できません。
+> Power BI Desktop モデルに接続している場合、このオプションはデフォルトでは使用できません。これは、[外部ツールの Power BI Desktop サポートの制限](xref:desktop-limitations) に起因するものです。詳しくはリンクをクリックしてください。
+
+> [!注意]を参照してください。
+> 計算テーブルの DAX 式が変更された場合、そのテーブルをレポートで使用する前にリフレッシュする必要があります。詳しくはを参照してください。
+
+## 計算グループの追加
+
+[計算グループ](https://docs.microsoft.com/en-us/analysis-services/tabular-models/calculation-groups?view=asallproducts-allversions)を追加するには、モデルまたは「テーブル」フォルダーを右クリックし、**作成 > 計算グループ** (ALT+7)を選択します。計算グループには名前を付けます。また、デフォルトの**Name**列には、別の名前を考えてください。
+
+> [!重要]。
+> このオプションは、互換性レベル1500以上のモデルでのみ利用可能です。
+
+計算項目を追加するには、新しく作成した計算グループを右クリックし、**Create > Calculation Item**を選択します。計算項目に名前を付け、上記のメジャーの場合と同様に **Expression Editor** を使用してそのDAX式を編集します。
+
+計算項目は、TOM Explorerでドラッグするか、**Properties** ビューで `Ordinal` プロパティを設定することにより、表示順序を変更できます。
+
+> [!注意]。
+> 計算項目が追加、名前変更、または計算グループから削除された場合、計算グループをリフレッシュしてからでないと、レポートで使用することができません。詳しくはを参照してください。
+
+## 一般的なモデリング操作
+
+## コピー／ペースト
+
+TOMエクスプローラーのすべてのオブジェクトはTabular Editorでコピー＆ペーストできます。異なるTabular Editorのインスタンス間、そしてTabular Editor 2.xとTabular Editor 3間でもコピー＆ペーストが可能です。おなじみのキーボードショートカットを使用できます。
+
+- 編集 > コピー** (CTRL+C)
+- 編集 > カット** (CTRL+X)
+- 編集 > 貼り付け** (CTRL+V)
+
+> [!TIP]です。
+> あるテーブルを別のテーブルに置き換え、そのテーブルとの既存のリレーションシップをすべて保持したい場合、テーブルをクリップボードにコピーし、TOMエクスプローラで置き換えたいテーブルを選択して貼り付けます。選択したテーブルをクリップボードにあるテーブルと置き換えるかどうか確認するプロンプトが表示されます。
+
+## 元に戻す/やり直し
+
+Tabular Editorのオブジェクトやプロパティに変更が加えられると、その変更履歴が完全に追跡され、加えられたすべての変更を元に戻すことができます。使い慣れたキーボードショートカットを使用できます。
+
+- 編集 > 元に戻す** (CTRL+Z)
+- 編集 > やり直し** (CTRL+Y)
+
+> [!注意]。
+> Tabular Editor 3のすべてのテキストエディタは、独自の取り消し/やり直し履歴を持つため、カーソルが現在テキストエディタ内にある場合、キーボードショートカットはそのエディタ内で入力の取り消し/やり直しを行います。モデルレベルでのアンドゥ/リドゥを実行するには、**Edit**メニューのオプションを使用するか、ユーザーインターフェイスの他の要素（TOM Explorerなど）をクリックして現在のテキストエディターを無効化することができます。
+
+## ナビゲーション
+
+DAXエディター内のオブジェクト参照にカーソルを合わせた状態で右クリックし、**Go to definition** (F12)を選択すると、そのオブジェクトに素早くジャンプできます。もちろん、TOMエクスプローラーを使用してオブジェクト間を移動することもできます。
+
+**式エディター**の右上にある矢印ボタンを使用すると、訪問したオブジェクト間を素早く行き来できます。
+
+## DAX依存関係
+
+オブジェクト間のDAX依存関係を表示するには、**TOM Explorer**でオブジェクトを選択し、右クリックして**Show dependencies** (SHIFT+F12)を選択します。これにより、選択したオブジェクトの依存関係（両方向）を表示するウィンドウが開きます。このウィンドウでオブジェクトをダブルクリックすると、そのオブジェクトにすばやく移動できます。
+
+Dax Dependencies And Tom Explorer](../../images/dax-dependencies-and-tom-explorer.png)
+
+## フォルダーを表示する
+
+モデルがかなりの数のメジャーを獲得し始めると、表示フォルダーを使用してそれらを整理することが良い習慣となります。Tabular Editorで、ディスプレイ・フォルダーを作成するには、**Properties** ビューで `Display Folder` プロパティを編集するか、またはメジャーを右クリックし**Create > Display Folder** オプションを選択します。
+
+また、ディスプレイフォルダー間でオブジェクトをカット／コピー／ペーストしたり、ドラッグ＆ドロップすることもできます。
diff --git a/onboarding/ja-jp/ja-cs-scripts-and-macros.md b/onboarding/ja-jp/ja-cs-scripts-and-macros.md
new file mode 100644
index 0000000..59f2526
--- /dev/null
+++ b/onboarding/ja-jp/ja-cs-scripts-and-macros.md
@@ -0,0 +1,133 @@
+# C#スクリプトとマクロの紹介
+
+生産性の向上を謳うソフトウェアであれば、ユーザーとのやりとりを**自動化する手段を提供する必要があります。Tabular Editorでは、まさにこの目的のためにC#スクリプトを書くことができます。Tabular EditorのC#スクリプトを使用すると、例えば次のようなことができます。
+
+- メジャー、テーブル、計算項目などのTOMオブジェクトの作成を自動化する。
+- TOMエクスプローラーで現在選択されているオブジェクトとのインタラクション
+- 複数のオブジェクトに自動的にプロパティを割り当てる
+- 監査や文書化のために、さまざまなフォーマットでメタデータをインポートおよびエクスポートする。
+
+スクリプトによってモデルのメタデータが変更された場合、TOM ExplorerとPropertiesビューで変更内容をすぐに確認できます。さらに、**スクリプトの変更を取り消す**ことができ、効果的にモデル・メタデータをスクリプト実行前のポイントにロールバックできます。スクリプトの実行に失敗した場合、デフォルトで自動的に変更がロールバックされます。
+
+Tabular Editor 3にはシンプルな**script recorder**があり、モデルに変更を加える際にスクリプトコードの行を徐々に追加することで、使用する構文の習得に役立ちます。
+
+スクリプトはスタンドアロンファイル（拡張子 `.csx`）として保存でき、Tabular Editorのユーザー間で共有できます。さらに、スクリプトは再利用可能な**マクロ**として保存することができ、スクリプトをTabular Editorのユーザーインターフェイスとより密接に統合させることができます。
+
+## スクリプトの作成
+
+新しいC#スクリプトを作成するには、**File > New > C# Script** メニューオプションを使用します。このオプションは、Tabular Editorにモデルがロードされていない場合でも利用できることに注意してください。
+
+最初のスクリプトには、次のコードを入力します。
+
+```csharp
+Info("Hello world!");
+```
+
+F5キーを押して、コードを実行します。
+
+あなたの最初のスクリプト](~/images/first-script.png)
+
+もし、コードを入力するときに間違えた場合は、シンタックスエラーが **Messages ビュー** に表示されます。
+
+- スクリプトをファイルとして保存するには、**ファイル > 保存** (Ctrl+S)を押すだけです。
+- ファイルからスクリプトを開くには、**ファイル > 開く > ファイル...** (Ctrl+O)オプションを使用します。ファイルを開くダイアログは、デフォルトで `.cs` または `.csx` の拡張子を持つファイルを探します。
+
+## スクリプトレコーダーの使用
+
+C#スクリプトにフォーカスがあるとき、Tabular Editorの**C# Script > Record script** メニューオプションを使用すると、スクリプトレコーダーを起動できます。スクリプトが記録されている間、モデルのメタデータに変更を加えると、スクリプトに追加のコード行が追加されます。記録を停止するまで、スクリプトを手動で編集することはできないので注意してください。
+
+
+
+## モデルのメタデータにアクセスする
+
+現在ロードされているモデル内の特定のオブジェクトにアクセスするためには、Tabular Object Model (TOM) 階層をナビゲートするためのC# 構文を使用する必要があります。この階層のルートは `Model` オブジェクトです。
+
+以下のスクリプトは、現在ロードされているモデルの名前を出力します。もし、モデルがロードされていない場合は、警告が表示されます。
+
+```csharp
+if(Model != null)
+ Info("現在のモデルの名前は: " + Model.Name);
+else
+ Warning("No model is currently loaded!");
+```
+
+`Model` オブジェクトは [Microsoft.AnalysisServices.Tabular.Model](https://msdn.microsoft.com/en-us/library/microsoft.analysisservices.tabular.model.aspx) クラスのラッパーであり、そのプロパティのサブセットを公開し、便宜上いくつかのメソッドとプロパティを追加しています。
+
+特定のメジャーにアクセスするには、そのメジャーの名前と、そのメジャーが存在するテーブルの名前を知っている必要があります。
+
+```csharp
+var myMeasure = Model.Tables["Internet Sales"].Measures["Internet Total Sales"];
+myMeasure.Description = "The formula for this measure is:" + myMeasure.Expression;
+```
+
+上記のスクリプトの行1は、"Internet Sales" テーブルの "Internet Total Sales" メジャーを特定し、そのメジャーへの参照を `myMeasure` 変数に格納します。
+
+スクリプトの2行目では、ハードコードされた文字列とメジャーの (DAX) 式に基づいて、メジャーの説明を設定しています。
+
+Tabular Editorは、TOM ExplorerからC#スクリプトビューにオブジェクトをドラッグ＆ドロップすることで、特定のオブジェクトを参照するコードを自動生成できます。
+
+ドラッグでオブジェクト参照を生成](~/images/generate-csharp-code.gif)
+
+Tabular EditorのほとんどのTOMオブジェクト（テーブル、カラム、メジャーなど）は、AMO/TOMクライアントライブラリを直接使用するときに利用できるのと同じプロパティのセットを公開しています。このため、どのプロパティが利用できるかは、[Microsoft's AMO/TOM documentation](https://docs.microsoft.com/en-us/dotnet/api/microsoft.analysisservices.tabular?view=analysisservices-dotnet) を参照するとよいでしょう。例えば、[こちら](https://docs.microsoft.com/en-us/dotnet/api/microsoft.analysisservices.tabular.measure?view=analysisservices-dotnet#properties) は、利用可能なメジャープロパティのドキュメントです。
+
+## 現在の TOM Explorer の選択にアクセスする
+
+スクリプトを再利用可能にするには、上記のように、モデル内のオブジェクトを名前で直接参照できるだけでは不十分なことがあります。その代わりに、Tabular Editorの**TOM Explorerビュー**で現在選択されているオブジェクトを参照することが有効です。これは `Selected` オブジェクトを使用することで可能になります。
+
+```csharp
+Info("現在、選択されています。" + Selected.Measures.Count + " メジャー(s).");
+```
+
+`Selected` オブジェクトは、それ自体、現在選択されているすべてのオブジェクトのコレクションで、選択されたディスプレイフォルダー内のオブジェクトも含まれます。さらに、`Selected` オブジェクトは複数のプロパティを含んでおり、上記の例で示した `.Measures` プロパティのような特定のオブジェクトタイプを簡単に参照できます。一般的に、これらのプロパティは、複数形（`.Measures`）と単数形（`.Measure`）の両方が存在します。一方、後者は現在選択されているオブジェクトへの参照であり、そのオブジェクトの種類が1つだけ選択されている場合にのみ使用できます。
+
+usful-script-snippetsの記事には、`Selected`オブジェクトを使用してさまざまなタスクを実行するスクリプトの例が多数掲載されています。
+
+## ユーザーとのインタラクション
+
+上記の例では、`Info(...)` と `Warning(...)` グローバルメソッドを使って、さまざまなフレーバーでユーザーへのメッセージを表示させることができました。Tabular Editorはこれらのグローバルメソッドに加え、情報を表示したり収集したりするための拡張メソッドや、その他さまざまな一般的なタスクのためのメソッドを多数提供しています。もっともよく使われるものを以下にリストアップします。
+
+* `void Output(object value)` - スクリプトの実行を停止し、提供されたオブジェクトに関する詳細な情報を表示する。提供されたオブジェクトがTOMオブジェクトまたはTOMオブジェクトのコレクションである場合、すべてのプロパティの詳細なビューが表示されます。
+* `void SaveFile(string filePath, string content)` - テキストデータをファイルに保存するための便利な方法です。
+* `string ReadFile(string filePath)` - ファイルからテキストデータをロードする便利な方法です。
+* `string ExportProperties(IEnumerable objects, string properties = "...")` - 複数のオブジェクトからプロパティのセットをTSV文字列としてエクスポートするための便利な方法です。
+* `void ImportProperties(string tsvData)` - 複数のオブジェクトに、TSV文字列からプロパティをロードする便利な方法です。
+* `string ConvertDax(dax, useSemicolons)` - DAX式をUS/UKと非US/UKロケールの間で変換します。`useSemicolons` がtrueの場合（デフォルト）、 `dax` 文字列はネイティブのUS/UKフォーマットからnon-US/UKフォーマットに変換されます。つまり、カンマ (リストセパレーター) はセミコロンに、ピリオド (小数点以下のセパレーター) はカンマに変換されます。UseSemicolons` がfalseに設定されている場合は、その逆となります。
+* `void FormatDax(IEnumerable objects, bool shortFormat, bool? skipSpace)` - 与えられたコレクション内のすべてのオブジェクトに対してDAX式をフォーマットします。
+* `void FormatDax(IDaxDependantObject obj)` - スクリプトの実行が完了したとき、あるいは `CallDaxFormatter` メソッドが呼ばれたときに、DAX式のフォーマット用にオブジェクトをキューに入れます。
+* `void CallDaxFormatter(bool shortFormat, bool? skipSpace)` - これまでにキューイングされたオブジェクトに対して、すべてのDAX式をフォーマットします。
+* `void Info(string message)` - 情報メッセージを表示します。
+* `void Warning(string message)` - 警告メッセージを表示する。
+* `void Error(string message)` - エラーメッセージを表示します。
+* `measure SelectMeasure(Measure preselect = null, string label = "...")` - すべてのメジャーのリストを表示し、ユーザが1つを選択するように促します。
+* `T SelectObject(this IEnumerable objects, T preselect = null, string label = "...") ここでT: TabularNamedObject` - 指定されたオブジェクトのリストを表示し、ユーザーに1つを選択するように促します。
+* `IList SelectObjects(this IEnumerable objects, IEnumerable preselect = null, string label = "...") where T: TabularNamedObject` - 提供されたオブジェクトのリストを表示し、ユーザーに任意の数のオブジェクトを選択するように促し、選択されたオブジェクトのリスト（またはキャンセルボタンが押された場合はnull）を返します。
+
+## スクリプトをマクロとして保存する
+
+よく使うスクリプトは再利用可能なマクロとして保存でき、Tabular Editorを起動すると常に利用可能です。さらに、マクロは**TOM Explorerビュー**のコンテキストメニューに自動的に統合され、**Tools > Customize...**オプションを使用して既存またはカスタムのメニューやツールバーにマクロを追加することも可能です。
+
+スクリプトをマクロとして保存するには、**C# Script > Save as Macro...** オプションを使用します。
+
+新しいマクロを保存](../../images/save-new-macro.png)
+
+マクロの名前を指定します。たとえば、"My MacrosTest "という名前を付けると、TOM Explorerのコンテキストメニューに "My Macros "というサブメニューができ、このサブメニューの中にスクリプトを呼び出す "Test "というメニューオプションができます。
+
+また、マクロによって作成されたメニューオプションの上にカーソルを置くと表示されるツールチップをオプションで指定できます。
+
+また、マクロのコンテキストを指定する必要があります。これは、コンテキストメニューでマクロを利用するために選択する必要があるオブジェクトの種類を指定します。
+
+最後に、**Macro enabled condition (advanced)** で、（通常は `Selected` または `Model` オブジェクトに基づいて）真/偽に評価されるべき C# 式を指定できます。これにより、現在の選択範囲に基づいて、マクロを有効にするかどうかをより詳細に制御できます。たとえば、以下のような表現が可能です。
+
+```csharp
+Selected.Measures.Count == 1
+```
+
+とすると、ちょうど1つのメジャーが選択されたときだけマクロを有効にできます。
+
+## マクロの管理
+
+過去に保存したすべてのマクロは、**マクロビュー**に表示できます。このビューを表示するには、メニューオプションの **表示 > マクロ** を使用します。このビューでは、以下のことが可能です。
+
+- **Rename a macro** (カーソルを**名前**列に置き、新しい名前を入力するだけ)
+- **Delete a macro.**それを選択し、マクロのリストの上にある赤い「X」ボタンをクリックします。
+- **Edit a macro.** リストでマクロをダブルクリックします（リストの「Id」列をダブルクリックします）。これにより、マクロが新しいC#スクリプトビューで開かれ、そこでコードを変更できます。Ctrl+Sを押して、コードの変更を保存します。他のマクロプロパティ（ツールチップ、マクロコンテキストなど）を編集する必要がある場合は、**C# Script > Edit Macro...** メニューオプションを使用します。
diff --git a/onboarding/ja-jp/ja-dax-script-introduction.md b/onboarding/ja-jp/ja-dax-script-introduction.md
new file mode 100644
index 0000000..69b763c
--- /dev/null
+++ b/onboarding/ja-jp/ja-dax-script-introduction.md
@@ -0,0 +1,198 @@
+# Using the DAX Scripting feature
+
+In the [previous article](xref:creating-and-testing-dax), you learned how to add and edit calculated objects such as measures, calculated columns, etc. in your model.
+
+As your model grows in complexity, you may reach a point in which it starts to become cumbersome to navigate the TOM Explorer or jump back and forth between measures, when authoring and maintaining business logic. It is not uncommon to have long chains of dependencies between measures, and so for that reason, it is sometimes useful to collect all the DAX code making up the business logic, in a single document.
+
+This is exactly the purpose of the new **DAX script** feature introduced in Tabular Editor 3.
+
+To use this feature, locate the measures for which you would like to generate a single document, in the TOM Explorer. Multi-select the measures, then right-click and choose **Script DAX**. A new document is created, containing the definition of all the selected measures. You can also generate a DAX script for all measures within a table or all measures within the model, by choosing the table or model object respectively.
+
+
+
+Editing objects through a DAX script is slightly different than editing through the **Expression Editor**. With the latter, changes are applied immediately when you navigate to a different object. In a DAX script, however, changes are not applied until you explicitly do so by using the **Script > Apply** (F5) option. If you are connected to an instance of Analysis Services, you can use the **Script > Apply & Sync** (SHIFT+F5) option to simultaneously apply the changes and save the updated model metadata to Analysis Services.
+
+## Working with DAX script files
+
+DAX scripts can be saved as text files, using the `.te3daxs` file extension. To save a DAX script as a file, simply use the **File > Save** (Ctrl+S) option. To open a DAX script from a text file, use the **File > Open > File...** (Ctrl+O) option.
+
+> [!NOTE]
+> DAX scripts are not model specific, but since DAX expressions may point to measures, columns and tables defined in the model, there are no guarantees that any DAX script can be applied to any model. DAX scripts are mostly useful for working with several DAX objects within a single document, in the context of a specific data model.
+
+## DAX script editor
+
+The DAX script editor has all the capabilities of the DAX editor used elsewhere in Tabular Editor 3. Specifically, auto-complete, auto-formatting, calltips, etc.
+
+In addition, to easily manage large DAX scripts, two dropdowns are displayed at the top of the DAX script view. The dropdown on the left allows you to jump between objects defined in the script, where as the dropdown on the right allows you to jump between properties on the current object.
+
+
+
+## Define measures
+
+If you want to include the definition of a measure that is referenced in the script, but not already defined in the script, you can do so by right-clicking on a measure reference, and choose the "Define Measure" or "Define Measure with dependencies" option.
+
+
+
+## Shortcuts
+
+To apply the script to the model, use the following shortcuts:
+
+- **F5**: Apply the entire script to the local model metadata
+- **Shift+F5**: Apply the entire script to the local model metadata, then save the model metadata back to the source
+- **F8**: Apply the currently selected part of the script to the local model metadata
+- **Shift+F8**: Apply the currently selected part of the script to the local model metadata, then save the model metadata back to the source
+
+## DAX objects supported
+
+Tabular Editor 3 supports editing the following types of objects using a DAX script:
+
+- Measures (including KPIs)
+- Calculated columns
+- Calculated tables
+- Calculation groups (including calculation items)
+
+# DAX script syntax
+
+The syntax for DAX scripts is the following:
+
+```dax
+:
+MEASURE 'Table name'[Measure name] =
+ []
+
+COLUMN 'Table name'[Column name] =
+ []
+
+TABLE 'Table name' =
+ [
:
+ Description = "string"
+ Visible = TRUE / FALSE
+ DetailRows =
+
+:
+ Description = "string"
+ Visible = TRUE / FALSE
+ Precedence =
+
+
+ Description = "string"
+ Ordinal =
+ FormatString =
+```
+
+## Example 1: Measure
+
+As an example, the script below defines the `[Internet Total Sales]` measure on the `'Internet Sales'` table. In addition to the DAX expression of the measure, the script also includes the measure description and format string.
+
+```dax
+----------------------------------
+-- Measure: [Internet Total Sales]
+----------------------------------
+MEASURE 'Internet Sales'[Internet Total Sales] = SUM('Internet Sales'[Sales Amount])
+ Description = "Returns the sum of all Internet Sales"
+ FormatString = "\$#,0.00;(\$#,0.00);\$#,0.00"
+```
+
+## Example 2: Measure with status and target KPI
+
+The DAX script below defines the `[Internet Current Quarter Sales Performance]` measure, which includes a KPI that has a status and a target expression. The status KPI uses the "Shapes" graphic.
+
+```dax
+--------------------------------------------------------
+-- Measure: [Internet Current Quarter Sales Performance]
+--------------------------------------------------------
+MEASURE 'Internet Sales'[Internet Current Quarter Sales Performance] =
+ IFERROR(
+ [Internet Current Quarter Sales] / [Internet Previous Quarter Sales Proportion to QTD],
+ BLANK()
+ )
+ , KpiStatusExpression =
+ VAR x = [Internet Current Quarter Sales Performance]
+ RETURN
+ IF(
+ ISBLANK( x ),
+ BLANK(),
+ IF(x < 1, -1, IF(x < 1.07, 0, 1))
+ )
+ , KpiStatusGraphic = "Shapes"
+ , KpiTargetExpression = 1.1
+```
+
+## Example 3: Calculation group
+
+The DAX script below defines the `'Time Intelligence'` calculation group with the `[Period]` column. The calculation group contains 6 calculation items that performs various time calculations. Notice how the `"YoY %"` item applies a different format string.
+
+```dax
+-----------------------------------------
+-- Calculation Group: 'Time Intelligence'
+-----------------------------------------
+CALCULATIONGROUP 'Time Intelligence'[Period]
+ Description = "Use this table to perform time calculations"
+
+ CALCULATIONITEM "Current" = SELECTEDMEASURE()
+ Ordinal = 0
+
+ CALCULATIONITEM "MTD" = TOTALMTD(SELECTEDMEASURE(), 'Calendar'[Date])
+ Ordinal = 1
+
+ CALCULATIONITEM "YTD" = TOTALYTD(SELECTEDMEASURE(), 'Calendar'[Date])
+ Ordinal = 2
+
+ CALCULATIONITEM "PY" = CALCULATE(SELECTEDMEASURE(), SAMEPERIODLASTYEAR('Calendar'[Date]))
+ Ordinal = 3
+
+ CALCULATIONITEM "YoY" =
+ SELECTEDMEASURE()
+ - CALCULATE(SELECTEDMEASURE(), SAMEPERIODLASTYEAR('Calendar'[Date]))
+ Ordinal = 4
+
+ CALCULATIONITEM "YoY %" =
+ VAR lastYear =
+ CALCULATE(SELECTEDMEASURE(), SAMEPERIODLASTYEAR('Calendar'[Date]))
+ RETURN
+ DIVIDE(
+ SELECTEDMEASURE() - lastYear,
+ lastYear
+ )
+ FormatString = "Percent"
+ Ordinal = 5
+```
+
+# Next steps
+
+- @bpa
+- @cs-scripts-and-macros
+- @personalizing-te3
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-general-introduction.md b/onboarding/ja-jp/ja-general-introduction.md
new file mode 100644
index 0000000..aaa2e1d
--- /dev/null
+++ b/onboarding/ja-jp/ja-general-introduction.md
@@ -0,0 +1,115 @@
+---
+uid: general-introduction
+title: General introduction and architecture
+author: Daniel Otykier
+updated: 2021-09-30
+---
+
+# General introduction and architecture
+
+Tabular Editor is a Windows desktop application for developing tabular models. Specifically, the tool lets you edit the Tabular Object Model (TOM) metadata. The tool can load the TOM metadata from a file or from an existing Analysis Services database, and it can also deploy updated TOM metadata to Analysis Services.
+
+> [!NOTE]
+> We use the term **tabular model** to represent both Analysis Services Tabular models as well as Power BI datasets, since Analysis Services Tabular is the data model engine used by Power BI. Similarly, when we use term **Analysis Services**, we mean "any instance of Analysis Services", which could be SQL Server Analysis Services, Power BI Desktop or the Power BI Service XMLA Endpoint.
+
+## Tabular Object Model (TOM) metadata
+
+A data model is made up by a number of tables. Each table has one or more columns, and a table may also contain measures and hierarchies. Typically, the data model also defines relationships between tables, data sources containing connection details and table partitions containing data source expressions (SQL or M queries) for loading data, etc. All of this information is collectively called the **model metadata**, and it is stored in a JSON based format known as the **Tabular Object Model (TOM)**.
+
+- When a tabular model is created using Visual Studio, the JSON representing the TOM metadata is stored in a file called **Model.bim**.
+- When a data model is created using Power BI Desktop, the TOM metadata is embedded within the .pbix or .pbit file (since this file format also contains a lot of other details, such as definitions of visuals, bookmarks, etc., which is not related to the data model itself).
+
+Using a client library called [AMO/TOM](https://docs.microsoft.com/en-us/analysis-services/tom/introduction-to-the-tabular-object-model-tom-in-analysis-services-amo?view=asallproducts-allversions), Tabular Editor is able to load and save metadata to and from this JSON based format. In addition, the client library allows Tabular Editor to connect directly to any instance of Analysis Services, in order to obtain the model metadata from an existing database. This is illustrated in the figure below.
+
+
+
+> [!NOTE]
+> In the paragraph above, we used the term **database** to represent a model that has been deployed to Analysis Services. Within the Power BI Service the term **dataset** is used to represent the same thing, namely a tabular model.
+
+Tabular Editor can load model metadata from the following sources:
+
+- [1] Model.bim files
+- [2] Database.json files (see @parallel-development for more information)
+- [3] .pbit files (Power BI Template)
+- [4] A database on SQL Server Analysis Services (Tabular)
+- [5] A database on Azure Analysis Services
+- [6] A dataset in a Power BI Premium* Workspace
+- [7] A Power BI Desktop report in Import/DirectQuery mode
+
+*Power BI Premium/Embedded Capacity or Power BI Premium-Per-User is required in order to enable the [XMLA Endpoint](https://docs.microsoft.com/en-us/power-bi/admin/service-premium-connect-tools). The XMLA Endpoint must be enabled for any third party tool to connect to Power BI datasets.
+
+> [!IMPORTANT]
+> Tabular Editor 2.x supports all sources 1-7 above. Tabular Editor 3 supports only some sources depending on which [edition of Tabular Editor 3](xref:editions) you are using.
+
+Once the model metadata has been loaded in Tabular Editor, the user is free to add/edit/remove **objects** and change **object properties**. Modifications are not saved back to the source until the user explicitly saves the model, either by choosing **File > Save** or by hitting CTRL+S. If the model metadata was loaded from a file source (sources 1-3 above), that file will then be updated. If the model metadata was loaded from Analysis Services (sources 4-7 above), then the changes are saved back to Analysis Services. Note that certain changes may cause objects to enter a state where they can no longer be queried by end-users. For example, if you add a column to a table, you will need to [refresh the table](xref:refresh-preview-query#refreshing-data) before users can query the contents of that table or any measures that dependent on the table.
+
+> [!WARNING]
+> Certain limitations apply when saving model metadata changes back to Power BI Desktop (source 7 above). See @desktop-limitations for more information.
+
+### TOM objects and properties
+
+The TOM metadata is made up of **objects** and **properties**.
+
+Examples of TOM **objects**:
+
+- Data Sources
+- Tables
+- Partitions
+- Measures
+- KPIs
+- Columns
+- Model Roles
+
+Examples of TOM **object properties**:
+
+- `Name` (text)
+- `Display Folder` (text)
+- `Description` (text)
+- `Hidden` (true/false)
+- `Summarize By` (one of: None, Sum, Min, Max, ...)
+
+Most properties are simple values (text, true/false, one-of-selections aka. enums), but properties can also reference other objects (for example, the `Sort By Column` property should reference a column). Properties can also be arrays of objects, such as the `Members` property on the Model Role object.
+
+Tabular Editor generally uses the same name for objects and properties as those defind in the [Microsoft.AnalysisServices.Tabular namespace](https://docs.microsoft.com/en-us/dotnet/api/microsoft.analysisservices.tabular?view=analysisservices-dotnet). If you want to learn more about specific TOM objects or properties, always consult the namespace documentation. For example, to learn what the "Summarize By" column property does, first locate the "Column" class in Microsoft's documentation, then expand "Properties" and scroll to "SummarizeBy". You should then get to [this article](https://docs.microsoft.com/en-us/dotnet/api/microsoft.analysisservices.tabular.column.summarizeby?view=analysisservices-dotnet).
+
+
+
+### Editing property values
+
+Both versions of Tabular Editor display the object model metadata in a hierarchical view known as the **TOM Explorer** view, which roughly corresponds to the hierarchical structure of the JSON metadata:
+
+
+
+In general, Tabular Editor lets you modify object properties by first selecting an object in the TOM Explorer (you can select multiple objects at once by holding down SHIFT or CTRL), and then simply editing the property value within the **Properties view** (see screenshot below).
+
+
+
+Tabular Editor does not perform explicit validation of modified property values, except for some basic rules (for example, object names cannot be empty, measure names have to be unique, etc.). It is your responsibility as a tabular model developer to know which properties to set and what values to use.
+
+If you make a mistake while editing property values, you can always press CTRL+Z (Edit > Undo) to roll back the last property change.
+
+## Architecture
+
+As hinted above, Tabular Editor has two different modes of operation: Metadata from file (aka. **file mode**) and metadata from Analysis Services (aka. **connected mode**). In addition, Tabular Editor 3 introduces a hybrid approach called [**workspace mode**](xref:workspace-mode).
+
+Before proceeding, it is important to understand the differences between these modes:
+
+- In **file mode**, Tabular Editor loads and saves all model metadata from and to a file on disk. In this mode, Tabular Editor cannot interact with model **data** (that is, table previews, DAX queries, Pivot Grids, and data refresh operations are not enabled). This mode can be used entirely offline, even when no instance of Analysis Services is available. The supported file formats for model metadata are:
+ - Model.bim (same format used by Visual Studio)
+ - Database.json (folder structure only used by Tabular Editor)
+ - .pbit (Power BI Template)
+- In **connected mode**, Tabular Editor loads and saves model metadata from and to Analysis Services. In this mode, it is possible to interact with model **data** using Tabular Editor 3 (table previews, DAX queries, Pivot Grids and data refresh). This mode requires connectivity to an instance of Analysis Services.
+- In **workspace mode**, Tabular Editor 3 loads model metadata from a file on disk AND deploys the metadata to Analysis Services. On subsequent saves (CTRL+S), updates are saved both to disk and to the connected instance of Analysis Services. It is possible to interact with model **data** similar to **connected mode**.
+
+### Metadata synchronization
+
+One of the major benefits of Tabular Editor over the standard tools (Visual Studio, Power BI Desktop), is that model metadata is only saved upon request. In other words, you can make multiple changes to objects and properties without having to wait for any Analysis Services instance to become synchronized between each change. The synchronization of the Analysis Services database is an operation that may take several seconds to complete, depending on the size and complexity of the data model. In Power BI Desktop, this synchronization happens every time the notorious "Working on it" spinner appears on the screen. In Tabular Editor, this only happens when you explicitly save your changes (CTRL+S).
+
+The downside is, of course, that you have to remember to explicitly save your changes, before you can test the impact of any metadata modifications that were made.
+
+## Next steps
+
+- @installation-activation-basic
+- @migrate-from-vs
+- @migrate-from-desktop
+- @migrate-from-te2
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-importing-tables-data-modeling.md b/onboarding/ja-jp/ja-importing-tables-data-modeling.md
new file mode 100644
index 0000000..961a4eb
--- /dev/null
+++ b/onboarding/ja-jp/ja-importing-tables-data-modeling.md
@@ -0,0 +1,72 @@
+---
+uid: importing-tables-data-modeling
+title: Importing tables and data modeling
+author: Daniel Otykier
+updated: 2021-10-08
+applies_to:
+ editions:
+ - edition: Desktop
+ partial: TE3 Desktop Edition includes this feature. External tools adding/editing tables, columns and relationships against a Power BI Desktop model is not supported by Microsoft, however.
+ - edition: Business
+ - edition: Enterprise
+---
+# Importing tables and data modeling
+
+This article describes how to use the [Table Import Wizard](#table-import-wizard) of Tabular Editor 3, to add new tables to the model. There is also a section on how to [update the table schema](#updating-table-schema) of an existing table. Lastly, we cover how to use the [diagram tool](#working-with-diagrams) to define and edit relationships between tables.
+
+## Table Import Wizard
+
+[!include[importing-tables1](~/te3/import-tables.partial.md)]
+
+# Working with diagrams
+
+In Tabular Editor 3, **diagrams** are documents that can be used to visualize and edit the relationships between tables in the model. You can create as many diagrams as you want to visualize certain areas of your model. A diagram can be saved as a stand alone file. See for more information.
+
+> [!NOTE]
+> We recommend creating multiple smaller diagrams over few large diagrams. When a diagram contains more than 20 or so tables, it quickly becomes overwhelming and difficult to understand.
+
+After loading a model in Tabular Editor 3, choose the **File > New > Diagram** menu option to create a new diagram.
+
+## Adding tables
+
+Add initial tables to the diagram in any of the following ways:
+
+- (Multi-)select tables in the TOM Explorer, then right-click and choose **Add to diagram**.
+- (Multi-)select tables in the TOM Explorer, then drag the tables over to the diagram
+- Use the **Diagram > Add tables...** menu option, and (multi-)select the tables you want to add through the dialog box.
+ 
+
+To add additional tables to the diagram, use the technique above again, or right-click on an existing table in the diagram and choose one of the following options:
+- **Add tables that filter this table**: Adds all tables to the diagram which may, directly or indirectly through other tables, filter the currently selected table. Useful when starting from a fact table.
+- **Add all related tables**: Adds all tables to the diagram which are directly related to the currently selected table. Useful when starting from a dimension table.
+ 
+
+Before proceeding, rearrange and resize the tables in the diagram to suit your preferences, or use the **Diagram > Auto-arrange** feature to have Tabular Editor 3 lay out the tables automatically.
+
+## Modifying relationships using the diagram
+
+To add a new relationship between two tables, locate the column on the fact table (many-side) of the relationship, and drag that column over to the corresponding column on the dimension table (one-side). Confirm the settings for the relationship and hit **OK**.
+
+
+
+To edit an existing relationship, right-click on it and choose **Edit relationship**. The right-click menu also contains shortcuts for reversing or deleting a relationship, as shown on the screenshot below.
+
+
+
+> [!NOTE]
+> You can also create relationships without using a diagram, through the TOM Explorer. Locate the column from which the relationship should start (many-side / fact-table side), right-click and choose **Create > Relationship from**. Specify the destination column in the Create Relationship dialog that appears on the screen.
+
+## Saving a diagram
+
+To save a diagram, simply use the **File > Save** (CTRL+S) option. Tabular Editor 3 will prompt you to save the diagram if you close the document or the application while the diagram has unsaved changes.
+
+> [!TIP]
+> The same diagram file can be loaded for different data models. Diagrams reference tables by their names. Any tables not present in the model upon diagram load are simply removed from the diagram.
+
+> [!NOTE]
+> Every time you add or modify a relationship, you will have to run a "calculate" refresh on the data model, before the relationships can be used when querying the model.
+
+# Next steps
+
+- @refresh-preview-query
+- @creating-and-testing-dax
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-index.md b/onboarding/ja-jp/ja-index.md
new file mode 100644
index 0000000..f369454
--- /dev/null
+++ b/onboarding/ja-jp/ja-index.md
@@ -0,0 +1,45 @@
+---
+uid: onboarding-te3
+title: Welcome
+author: Daniel Otykier
+---
+# Welcome
+
+
+
+**Thank you for choosing Tabular Editor 3!**
+
+To help you get the most out of the tool, we have collected all of our onboarding material in this onboarding guide, that we hope you will enjoy. We recommend all new users of Tabular Editor 3 to read through this guide, skipping any topics that they are already familiar with.
+
+> [!NOTE]
+> Some articles in this guide reference Tabular Editor 2, specifically the Command-Line Interface (CLI), for purposes of automated deployment and testing. A standalone CLI application to accompany Tabular Editor 3 is planned for release at a later time.
+
+As this training material is focused on the Tabular Editor product, we assume that you already have a basic understanding of tabular data modeling (using either Power BI Desktop, Visual Studio or Tabular Editor 2.x). If you are new to tabular data modeling, we highly recommend looking into some of the training material and courses offered by third parties such as [sqlbi.com](https://sqlbi.com).
+
+**Topics covered in this guide:**
+
+- @general-introduction
+ - @installation-activation-basic
+ - @migrate-from-vs
+ - @migrate-from-desktop
+ - @migrate-from-te2
+- @parallel-development
+ - @optimizing-workflow-workspace-mode
+ - @powerbi-cicd
+ - @as-cicd
+- @boosting-productivity-te3
+ - @importing-tables-data-modeling
+ - @refresh-preview-query
+ - @creating-and-testing-dax
+ - @dax-script-introduction
+ - @bpa
+ - @cs-scripts-and-macros
+ - @personalizing-te3
+
+**Additional resources:**
+
+- [TE3 reference docs](xref:getting-started)
+- @downloads
+- [Dedicated support (Enterprise Edition customers only)](mailto:support@tabulareditor.com)
+- [Community support](https://github.com/TabularEditor/TabularEditor3/issues)
+- [Community discussions](https://github.com/TabularEditor/TabularEditor3/discussions)
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-installation.md b/onboarding/ja-jp/ja-installation.md
new file mode 100644
index 0000000..36201ec
--- /dev/null
+++ b/onboarding/ja-jp/ja-installation.md
@@ -0,0 +1,75 @@
+---
+uid: installation-activation-basic
+title: Installation, activation and basic configuration
+author: Daniel Otykier
+updated: 2021-09-30
+---
+
+## Installation
+
+In order to install Tabular Editor 3, download the latest version from our [downloads page](xref:downloads).
+
+We recommend downloading the MSI 64-bit installer, which is suitable in most scenarios. Once downloaded, doubleclick the MSI file and go through the installation pages.
+
+
+
+## Activating your installation
+
+The first time you launch Tabular Editor 3 on a new machine, you are prompted to activate the product.
+
+
+
+### Activating using an existing license key
+
+Once you purchase a license for Tabular Editor 3, you should receive an e-mail with a 25-character string which is your license key. When prompted, enter the license key and hit "Next >" to activate the product.
+
+
+
+> [!NOTE]
+> For multi-user license types, you will need to enter your e-mail address in addition to the license key. Tabular Editor 3 will prompt you to do so, if the license key you enter represents a multi-user license.
+
+### Changing a license key
+
+When Tabular Editor 3 is activated, you may change your license key in the Help menu by choosing "About Tabular Editor".
+
+
+
+In the dialog, select "Change license key". Note that this option is only available if no model is loaded in Tabular Editor. IF you already loaded a model you can close it under File > Close model.
+
+For more details on managing the license keys, see [Registry details](xref:getting-started#registry-details).
+
+## Basic configuration
+
+After Tabular Editor 3 is activated, we recommend spending a few minutes familiarizing yourself with the [basic interface](xref:user-interface). In addition, Tabular Editor 3 provides many different configuration options. The default settings are sufficient for most development scenarios, but there are a few important configuration options that you should always review.
+
+### Check for updates on start-up
+
+By default, whenever Tabular Editor 3 is launched, the tool will check online to see if a newer version is available. You can control how this update check is performed under **Tools > Preferences > Updates and Feedback**.
+
+> [!NOTE]
+> We recommend always using the latest version of Tabular Editor 3. Our support team will generally assume that you are always using the latest version before submitting a bug report.
+
+### Opting out of telemetry collection
+
+Tabular Editor 3 collects anonymous usage data and telemetry, which helps us improve the product. You can opt out at any time by launching Tabular Editor 3 and navigating to **Tools > Preferences > Updates and Feedback**. Uncheck the **Help improve Tabular Editor by collecting anonymous usage data** checkbox to opt out.
+
+
+
+### Proxy settings
+
+If you are on a network with limited Internet connectivity, you can specify the address, username and password of a proxy server under **Tools > Preferences > Proxy Settings**. This is required before Tabular Editor 3 can use any features that rely on outgoing web requests. Specifically, these are:
+
+- Update checks
+- Product activation
+- DAX Formatting
+- Download of Best Practice Rules from external URLs
+
+### Other preferences
+
+In addition to the settings mentioned above, Tabular Editor 3 contains many other settings for controlling various application behavior, allowing you to closely tailor the tool to your needs. To learn more about other these settings, see @preferences.
+
+## Next steps
+
+- @migrate-from-vs
+- @migrate-from-desktop
+- @migrate-from-te2
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-migrate-from-desktop.md b/onboarding/ja-jp/ja-migrate-from-desktop.md
new file mode 100644
index 0000000..188881e
--- /dev/null
+++ b/onboarding/ja-jp/ja-migrate-from-desktop.md
@@ -0,0 +1,236 @@
+---
+uid: migrate-from-desktop
+title: Migrating from Power BI Desktop
+author: Daniel Otykier
+updated: 2021-09-30
+---
+
+# Migrating from Power BI Desktop
+
+If you are already familiar with data modeling concepts in Power BI Desktop, this article is intended to help you migrate your data modeling over to Tabular Editor. Thus, we assume you have a solid understanding of concepts such as the Power Query Editor, imported vs. calculated tables, calculated columns, measures, etc.
+
+## Power BI and Tabular Editor
+
+Historically, Tabular Editor was designed as a tool for SQL Server Analysis Services (Tabular) and Azure Analysis Services developer. When Power BI first launched, there was no supported way for third party tools to access the Analysis Services instance hosting the Power BI data model, and so the only way to create and edit a Power BI dataset, was through Power BI Desktop.
+
+This changed in March 2020, when [Microsoft announced the read/write XMLA endpoint in Power BI Premium](https://powerbi.microsoft.com/en-us/blog/announcing-read-write-xmla-endpoints-in-power-bi-premium-public-preview/). A few months later, it even became possible to use third party tools in conjunction with Power BI Desktop, with the [announcement of the External Tools feature](https://powerbi.microsoft.com/en-us/blog/announcing-public-preview-of-external-tools-in-power-bi-desktop/).
+
+The availability of the XMLA endpoint in Power BI Premium allows data model developers to leverage their existing skills and tools, and it is not a secret that Microsoft is investing heavily in making [Power BI Premium a superset of Analysis Services](https://community.powerbi.com/t5/Webinars-and-Video-Gallery/Power-BI-Premium-as-a-superset-of-Analysis-Services-the-XMLA/m-p/1434121). In other words, the integration of third party tools, community as well as commercial, with Power BI is something that is here to stay. In fact, Amir Netz, CTO of Microsoft Analytics, made a [joint statement](https://powerbi.microsoft.com/en-us/blog/community-tools-for-enterprise-powerbi-and-analysisservices/) with Marco Russo, founder of SQLBI, to affirm this point.
+
+Here at Tabular Editor ApS, we firmly believe that Tabular Editor 3 is the best tabular data modeling tool available right now, and thanks to the integrations mentioned above, the tool is no longer reserved for SQL Server or Azure Analysis Services developers.
+
+Before proceeding, it is important to understand that Tabular Editor can be used in conjunction with Power BI in two very different scenarios:
+
+- **Scenario 1:** Tabular Editor as an External Tool for Power BI Desktop.
+- **Scenario 2:** Tabular Editor with the Power BI Premium XMLA Endpoint.
+
+> [!IMPORTANT]
+> You cannot use Tabular Editor to directly load a .pbix file. For more information, see .
+
+### Scenario 1: Tabular Editor as an External Tool for Power BI Desktop
+
+Generally, this scenario is intended for self-service analysts and Power BI Desktop users without access to Power BI Premium, to make certain data modeling operations easier (for example, adding and editing measures), and to unlock advanced modeling options not otherwise available (calculation groups, perspectives and metadata translations).
+
+External tools connect to the Analysis Services model hosted by Power BI Desktop. This allows the tool to make certain changes to the data model. Currently, however, not all types of data modeling operations are supported by Power BI Desktop. It is important to understand this limitation and how Tabular Editor behaves when used as an external tool for Power BI Desktop. See for more information about this.
+
+The typical workflow in this scenario, is the following:
+
+1. Open a .pbit or .pbix file in Power BI Desktop
+2. Launch Tabular Editor through the External Tools ribbon
+3. Switch back and forth between Tabular Editor and Power BI Desktop, depending on what type of change you need to make. For example, you can add and edit measures through Tabular Editor, but you must use Power BI Desktop if you need to add a new table to the model.
+4. Whenever you make a change in Tabular Editor, use **File > Save** (CTRL+S) to write the changes back to Power BI Desktop.
+5. When you are done making changes, close Tabular Editor. Then, publish or save the report as usual from within Power BI Desktop.
+
+> [!NOTE]
+> As of October 2021, there is a bug in Power BI Desktop that sometimes prevents Desktop from automatically refreshing the field list and visuals to reflect changes made through external tools. When this happens, saving the .pbix file and reopening it, or manually refreshing a table within the model, usually causes the field list and all visuals to update correctly.
+
+The [modeling limitations](xref:desktop-limitations) that apply to External Tools are only relevant regarding write operations/model modifications. You can still use Tabular Editor 3's connected features to browse the data within the model through table data previews, Pivot Grids or DAX queries, as described later in this guide.
+
+### Scenario 2: Tabular Editor with the Power BI Premium XMLA Endpoint
+
+This scenario is for BI professionals in organizations that use Power BI Premium Capacity or Power BI Premium-Per-User workspaces, who intend to replace Power BI Desktop altogether for purposes of dataset development.
+
+Essentially, the Power BI Premium XMLA Endpoint exposes an instance of Analysis Services (Tabular). In this scenario, Tabular Editor behaves no different than it would when connected to Azure Analysis Services or SQL Server Analysis Services (Tabular).
+
+The typical workflow in this scenario, is the following:
+
+1. When first migrating to Tabular Editor, use the XMLA endpoint to open a Power BI dataset in Tabular Editor, then save the model metadata as a file (Model.bim) or folder (Database.json). See @parallel-development for more information.
+2. Going forward, open the model metadata in Tabular Editor from the file or folder you saved in step 1. Optionally use [workspace mode](xref:workspace-mode).
+3. Apply changes using Tabular Editor.
+4. If using workspace mode, changes should be immediately visible in the Power BI service every time you hit Save (CTRL+S) in Tabular Editor.
+5. If not using workspace mode or when done making changes, use Tabular Editor's **Model > Deploy...** option to publish the changes to the Power BI service.
+
+As the model metadata "source of truth" in this scenario, is the file or folder structure stored on disk, this scenario not only enables parallel development with version control integration, but also continuous integration/continuous deployment (CI/CD) using an automated build server such as Azure DevOps. See for more information.
+
+> [!WARNING]
+> As soon as you apply changes to a Power BI dataset through the Power BI service XMLA endpoint, that dataset can no longer be downloaded as a .pbix file. See [Dataset connectivity with the XMLA endpoint](https://docs.microsoft.com/en-us/power-bi/admin/service-premium-connect-tools#power-bi-desktop-authored-datasets) for more information.
+
+When using Tabular Editor to connect to the dataset through the XMLA endpoint, there are no limitations to the types of write operations/model modifications that can be made.
+
+The remainder of this article focuses on differences between Power BI Desktop and Tabular Editor for data model development. Some sections only apply to scenario 2, due to the [modeling limitations](xref:desktop-limitations) that apply when using Tabular Editor as an external tool for Power BI Desktop (scenario 1).
+
+## Tabular Editor 3 user interface
+
+If you are new to Tabular Editor, we recommend reading through the following resources to understand Tabular Editor 3's user interface:
+
+- [Getting to know Tabular Editor 3's User Interface](xref:user-interface)
+- [TOM Explorer view](xref:tom-explorer-view)
+- [Properties view](xref:properties-view)
+- [DAX editor](xref:dax-editor)
+
+## Tabular Editor 3 how-tos
+
+What follows is a quick walkthrough of how to achieve common tasks in Tabular Editor 3.
+
+### How to add a measure
+
+To add a new measure to your model, right-click on the table in the **TOM Explorer** on which you want the new measure to reside, then choose **Create > Measure** (shortcut ALT+1). After the measure is added, you can immediately type the name of the measure.
+
+
+
+### How to rename a measure
+
+If you need to edit the name of the measure (or any other object), simply select the measure and hit F2 (or double-click the measure name). If multiple objects are selected, you will see the Batch rename dialog, that makes it easy to rename multiple objects in one go.
+
+
+
+> [!WARNING]
+> Changing object names in the data model may cause report visuals to stop working, if the visuals relies on one or more of the objects being renamed. External tools cannot access information about Power BI visuals, so Tabular Editor is not able to warn you before an object that is used in a visual is renamed or deleted.
+
+### How to create a copy of a measure
+
+In Tabular Editor 3, you can use the familiar Cut (CTRL+X), Copy (CTRL+C) and Paste (CTRL+V) operations to quickly move around and make copies of objects. You can also drag objects between tables and display folders using the **TOM Explorer**. If you make a mistake along the way, you can use the Undo (CTRL+Z) and Redo (CTRL+Y) options (repeatedly) to navigate back and forth through the history of changes applied.
+
+### How to modify the DAX expression of a measure
+
+Locate the measure you want to modify in the **TOM Explorer** and select it. You can toggle the display of hidden objects (CTRL+6) and display folders (CTRL+5) using the toolbar buttons near the top of the TOM Explorer. You may also type the partial name of the measure in the search box, to filter the **TOM explorer**.
+
+Once the measure is selected, you should see the DAX expression of the measure in the **Expression Editor** and various properties such as `Description`, `Format String`, `Hidden`, etc. in the **Properties** grid.
+
+
+
+To modify the DAX expression, simply place the cursor in the **Expression Editor** and update the DAX code. Hit F6 to automatically format the code. If you select a different object in the TOM Explorer or click the green checkmark button **Expression > Accept** (F5), the expression change is stored locally in Tabular Editor. You can also cancel the modification you made by hitting the red "X", **Expression > Cancel**. If you accidentally hit **Accept**, you can always undo the change by using the **Edit > Undo** (CTRL+Z) option.
+
+To save your changes back to Power BI Desktop, the Power BI XMLA endpoint, or the file on disk from which the model was loaded, hit **File > Save** (CTRL+S).
+
+To learn more about the capabilities of the Expression Editor, when writing DAX code, see .
+
+### How to visualize dependencies between measures
+
+While a measure is selected in the **TOM Explorer** use the **Measure > Show dependencies** (SHIFT+F12) option. This causes a new window to pop up, visualizing the dependency tree of the DAX expression for that measure. You can switch between viewing both upstream and downstream dependencies.
+
+
+
+Double-clicking on an item in the dependencies view navigate to that object in the **TOM Explorer**.
+
+### How to change the format string of a measure
+
+Locate the measure you want to modify in the **TOM Explorer** and select it. You can toggle the display of hidden objects (CTRL+6) and display folders (CTRL+5) using the toolbar buttons near the top of the TOM Explorer. You may also type the partial name of the measure in the search box, to filter the **TOM explorer**.
+
+Once the measure is selected, locate the `Format String` property in the **Properties** grid, expand it, and set the format string properties according to your preferences. Note the dropdown button at the right of the `Format` property. You may also freely enter a format string in the `Format String` property itself.
+
+
+
+### How to modify the DAX expression of multiple measures
+
+Tabular Editor 3 allows you to select multiple measures in order to create a **DAX Script**, which lets you modify the DAX expression and various properties of all selected measures at once.
+
+To create a DAX script based on existing measures, simply select the measures in the **TOM Explorer** (hold down the CTLR key to select multiple objects or hold down the SHIFT key to select a range of objects). Then, right click and hit **Script DAX**.
+
+
+
+You can add or modify properties such as `Description`, `FormatString`, `Visible`, `DetailRows` and more directly in the script.
+
+Hit F5 to apply the script to the data model. Note that unlike the **Expression Editor**, navigating to a different object will not automatically apply any changes made to the script. You can still use the **Edit > Undo** (CTRL+Z) option to roll back any changes applied by a DAX script.
+
+See @dax-script-introduction for more information.
+
+### How to preview data in a table
+
+To view the contents of a table (similar to the Data Tab in Power BI Desktop), simply right-click on a table and choose "Preview data". This will open a new tab containing a preview of the table content. You can scroll through all rows of the table, as well as apply sorting or filtering to columns. Unlike Power BI Desktop, you can open as many of these preview tabs as you like and arrange them next to each other in the user interface. The preview also works for tables in [DirectQuery mode](https://docs.microsoft.com/en-us/power-bi/connect-data/desktop-use-directquery) (although the preview will be limited to the first 100 records).
+
+
+
+> [!NOTE]
+> The **Preview data** feature is only available when Tabular Editor is connected to Power BI Desktop or a dataset in the Power BI XMLA endpoint.
+
+See @refresh-preview-query for more information.
+
+### How to add a calculation group
+
+[Calculation Groups](https://docs.microsoft.com/en-us/analysis-services/tabular-models/calculation-groups?view=asallproducts-allversions) are useful for defining and reusing a modified DAX filter context or other type of business logic across all model measures. To add a calculation group using Tabular Editor, simply use the **Model > New Calculation Group** (ALT+7) option.
+
+
+
+Give the calculation group a name, then, while the Calculation Group is selected in the **TOM Explorer**, add new Calculation Items by using the **Calculation Group Table > Create > Calculation Item** option. You can copy (CTRL+C) and paste (CTRL+V) calculation items to speed up this process for additional items.
+
+
+
+### How to add a new table
+
+To add a new table to a model, use the **Model > Import tables...** option. Tabular Editor's [Import Table Wizard](xref:importing-tables) will guide you through the process.
+
+> [!NOTE]
+> Tabular Editor 3 does not support every data source otherwise supported by Power BI. If your model uses a data source not supported by Tabular Editor, the easiest way to import a new table from the same source is to copy an existing table in Tabular Editor (CTRL+C / CTRL+V), and then modify the partition expression and update the table schema as shown below. For this to work, make sure that the **Tools > Preferences > Schema Compare > Use Analysis Services for change detection** option is enabled. See for more information.
+
+> [!IMPORTANT]
+> This option is not available by default when using Tabular Editor as an external tool, since adding/editing tables through external tools is [not supported by Power BI Desktop](xref:desktop-limitations).
+
+See @importing-tables-data-modeling for more information.
+
+### How to modify a Power Query expression on a table
+
+Power Query (M) expressions that define what is loaded into each table reside in the corresponding table's **Partition**. The partitions can be located in the **TOM Explorer**. When selecting a partition, Tabular Editor displays the M expression for that partition in the **Expression Editor**, allowing you to edit it. After editing and accepting the expression change, you can right-click on the partition in the **TOM Explorer** and choose the **Update table schema...** option in order to detect if the columns imported on the table should be changed, based on the updated Power Query expression.
+
+
+
+> [!NOTE]
+> Currently, Tabular Editor 3 does not perform any validation of the partition expression. For Power Query (M) expressions, this is planned for a later update of Tabular Editor 3.
+
+> [!IMPORTANT]
+> Partition expressions are read-only by default when using Tabular Editor as an external tool, since editing partitions through external tools is [not supported by Power BI Desktop](xref:desktop-limitations).
+
+If the Power Query expression changes gives rise to any changes on the imported table columns, a dialog that lets you review these changes will show:
+
+
+
+### How to modify a shared Power Query expression
+
+Shared Expressions are M queries that are not directly used to load data into a table. For example, when you create a Power Query parameter in Power BI Desktop, the M expression for this parameter is stored as a Shared Expression. In Tabular Editor, These can be accessed through the Shared Expressions folder of the **TOM Explorer** and edited just like M queries on partitions.
+
+
+
+> [!IMPORTANT]
+> Shared expressions are read-only by default when using Tabular Editor as an external tool, since editing partitions through external tools is [not supported by Power BI Desktop](xref:desktop-limitations).
+
+### How to add relationships between tables
+
+The easiest way to add relationships between two tables is to create a new diagram, add the two tables to the diagram, and then visually dragging a column from one table to another, to indicate the columns that should participate in the relationship. This is similar to how you would create a relationship in Power BI Desktop.
+
+1. To create a new diagram use the **File > New > Diagram** option.
+2. To add tables to the diagram, either drag and drop the tables from the **TOM Explorer** or use the **Diagram > Add tables...** option.
+3. Once the tables are added, locate the column on the (many-side) fact table, and drag it over to the corresponding column on the (one-side) dimension table.
+4. Confirm the relationship settings and hit "OK".
+
+
+
+See [Working with diagrams](xref:importing-tables-data-modeling#working-with-diagrams) for more information.
+
+> [!IMPORTANT]
+> Relationships cannot be modified when using Tabular Editor as an external tool, since editing relationships through external tools is [not supported by Power BI Desktop](xref:desktop-limitations).
+
+### How to publish to the Power BI Service
+
+To publish or update a dataset in the Power BI Service, use the **Model > Deploy...** option and use the XMLA endpoint of the workspace, in which you want to publish the dataset.
+
+If you loaded the model metadata directly from the XMLA Endpoint, you only need to hit **File > Save** (CTRL+S), to update the dataset that was loaded in Tabular Editor.
+
+> [!NOTE]
+> The **Model > Deploy...** option is **not** available in Tabular Editor 3 Desktop Edition, as this edition is only intended to be used as an External Tool for Power BI Desktop. [More information](xref:editions).
+
+## Next steps
+
+-
+- @parallel-development
+- @boosting-productivity-te3
+-
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-migrate-from-te2.md b/onboarding/ja-jp/ja-migrate-from-te2.md
new file mode 100644
index 0000000..400a01d
--- /dev/null
+++ b/onboarding/ja-jp/ja-migrate-from-te2.md
@@ -0,0 +1,130 @@
+# Tabular Editor 2.xからの移行
+
+この記事は、Power BI DatasetまたはAnalysis Services Tabular開発でTabular Editor 2.xの使用経験がある開発者を対象としています。この記事では、Tabular Editor 3の類似点と重要な機能追加をハイライトし、迅速にスピードアップできるようにします。
+
+## インストールのサイドバイサイド
+
+Tabular Editor 3はTabular Editor 2.xと異なる製品コードを持っています。これは、両方のツールを問題なく並べてインストールできることを意味します。実際、両ツールは別々のプログラムフォルダーにインストールされ、その設定も別々のフォルダーに保存されます。つまり、Tabular Editor 2.xとTabular Editor 3間の「アップグレード」「ダウングレード」という言葉は当てはまりません。Tabular Editor 3はまったく別の製品であると考えた方がよいでしょう。
+
+## 機能比較
+
+機能面では、Tabular Editor 3はいくつかの例外を除き、基本的にTabular Editor 2.xのスーパーセットです。下の表は2つのツールのすべての主要機能を比較したものです。
+
+||Tabular Editor 2.x|Tabular Editor 3|
+|---|---|---|
+|すべてのTOMオブジェクトとプロパティを編集する|✔|✔|
+|一括編集とリネーム|✔|✔|
+|コピー＆ペースト、ドラッグ＆ドロップに対応|✔|✔|
+|データモデリング操作のアンドゥ／リドゥ|✔|✔|
+|モデルメタデータのディスクへのロード/セーブ|✔|✔*|
+|フォルダに保存|✔|✔*|
+|[daxformatter.com](https://daxformatter.com) integration|✔|✔|
+|高度なデータモデリング（OLS、Perspectives、Calculation Groups、Metadata Translations、など）|✔|✔*|
+|シンタックスハイライトと数式の自動修正|✔|✔|
+|オブジェクト間のDAX依存関係を表示|✔|✔|
+|テーブルのインポートウィザード|✔|✔|
+|デプロイメントウィザード|✔|✔*|
+|ベストプラクティス・アナライザー|✔|✔|
+|C#スクリプトと自動化|✔|✔|
+|Power BI Desktopの外部ツールとしての利用|✔|✔|
+|SSAS/Azure AS/Power BI Premiumに接続する。|✔|✔*|
+|コマンドラインインターフェース|✔|*[Coming soon](xref:roadmap)*|
+|高DPI、マルチモニター、テーマ設定に対応したカスタマイズ可能なプレミアム・ユーザー・インターフェイス||✔|
+|IntelliSenseTM ライクな機能を備えたワールドクラスのDAXエディター||✔|
+|オフラインでのDAX構文チェックとカラム/データ型推論||✔|
+|テーブルインポートウィザードとテーブルスキーマの更新チェックを改良し、Power Queryに対応しました。||✔|
+|DAXクエリ、テーブルプレビュー、ピボットグリッド||✔|
+|テーブルの関係を視覚化し、編集するためのダイアグラムを作成||✔|
+|バックグラウンドでのデータリフレッシュ操作の実行||✔*|
+|C#マクロレコーダー||✔|
+|DAXスクリプトを使用して、1つのドキュメントで複数のDAX式を編集する。||✔|
+|[VertiPaq Analyzer](https://www.sqlbi.com/tools/vertipaq-analyzer/)の統合。||✔|
+
+**Note:** Tabular Editor 3のどの[エディション](xref:editions)を使用しているかによって制限があります。
+
+## 機能の違い
+
+以下は、重要な機能の違いの概要です。
+
+### ユーザーインターフェイス
+
+Tabular Editor 3を起動して最初に気づくのは、新しいVisual Studio Shellのようなインターフェイスでしょう。このインターフェイスは完全にカスタマイズ可能で、高DPI、マルチモニターをサポートし、テーマの変更も可能です。すべてのインターフェイス要素は別の場所に移動できますので、もしTabular Editor 2.xのインターフェイスレイアウトがお好みでしたら、すぐに**Window**メニューから**Classic layout**を選択してください。
+
+しかし、一般的にTabular Editor 2.xに存在するインターフェイス要素はTabular Editor 3でも同じ名前なので、新しいインターフェイスをナビゲートするのは比較的簡単でしょう。いくつかの重要な違いを以下に挙げます。
+
+- Tabular Editor 2.xの**Advanced Scripting**タブはなくなりました。Tabular Editor 3では、代わりに**File > New**メニューを使用して*C# Scripts**を作成します。一度に1つのスクリプトで作業できるように制限されていません。また、**Custom Action** は **Macros** に名称が変更されました。
+- **ダイナミックLINQフィルタリング** は、現在TOM Explorer内では使用できません。代わりに、[Dynamic LINQ](https://dynamic-linq.net/expression-language) を使用してオブジェクトを検索する場合は、CTRL+Fキーを押して**検索と置換**ダイアログを表示させる必要があります。
+- **Expression Editor**を閉じた場合は、**TOM Explorer** 内のオブジェクトのアイコンをダブルクリックするか、**View > Expression Editor** メニューオプションを選択することで、元に戻すことができます。
+- Tabular Editor 3のデフォルトレイアウトを使用している場合、**Best Practice Analyzer**は**TOM Explorer**の隣にタブとして配置されます。ここでは、新しい**Data Refresh**ビュー（バックグラウンド更新操作のキューを表示可能）と**Macros**ビュー（以前にC#スクリプトから保存したマクロを管理可能）も表示されます。
+- Tabular Editor 3は新しい**Messages View**にすべてのDAXシンタックスとセマンティックエラーを表示します。デフォルトのレイアウトでは、これはインターフェイスの左下に配置されています。
+- さらに、Tabular Editor 3には**VertiPaq Analyzer**（[DAX Studio](https://daxstudio.org/)でお馴染みのもの）が含まれています。
+- 最後に、Tabular Editor 3は**ドキュメント**という概念を導入しており、これはC#スクリプト、DAXスクリプト、DAXクエリー、ダイアグラム、データプレビュー、ピボットグリッドの単なる総称に過ぎません。
+
+詳細は、を参照してください。
+
+### 新しい DAX エディターとセマンティック機能
+
+Tabular Editor 3は独自のDAX解析エンジン（別名「セマンティックアナライザー」）を備えており、モデル内のあらゆるDAXコードのセマンティクスを理解することができるようになったことを意味します。このエンジンは、DAXエディター（コードネーム「Daxscilla」）にも使用されており、構文の強調表示、自動フォーマット、コード補完、コールチップ、リファクタリングなどの機能を実現しています。もちろん、このエディターは高度に設定可能であり、好みのDAXコーディングスタイルに合わせて微調整できます。
+
+新しいDAXエディターの詳細については、 を参照してください。
+
+さらに、セマンティック アナライザーは、モデル内のすべてのオブジェクトでDAX構文またはセマンティック エラーを継続的に報告します。これは、Analysis Servicesに接続されていない場合でも動作し、非常に高速です。セマンティックアナライザーはまた、Tabular Editor 3がDAX式からデータ型を自動的に推論することを可能にしました。言い換えれば、Tabular Editor 3は計算されたテーブル式からどのカラムが得られるかを自動的に検出するのです。これは、計算テーブルのカラムを手動でマッピングするか、カラムのメタデータを返すためにAnalysis Services依存しなければならなかったTabular Editor 2.xに比べて大きな改善点です。
+
+### Power Queryをサポートするテーブルインポートとスキーマアップデート
+
+Tabular Editor 2.xに対するTabular Editor 3のもう1つの大きな利点は、構造化データソースとPower Query（M）パーティションをサポートすることです。具体的には、「スキーマアップデート」機能がこれらのタイプのデータソースやパーティションに対して機能するようになり、テーブルインポートウィザードでは新しいテーブルをインポートする際に必要なMコードを生成することができるようになったのです。
+
+スキーマ比較ダイアログ自体にも多くの改良が加えられており、たとえば、列削除＋列挿入の操作を単一列の名前変更操作に簡単にマッピングできます（逆も同様）。また、浮動小数点データ型と小数点のデータ型をどのように扱うかを制御するオプションもあります（たとえば、データソースが浮動小数点データ型を使っていても、常に小数点のデータ型としてインポートしたい場合があります）。
+
+詳しくは、を参照してください。
+
+### ワークスペース・モード
+
+このモードではモデルのメタデータはディスク（Model.bimまたはDatabase.json）から読み込まれ、選択したAnalysis Servicesインスタンスにデプロイされます。保存(CTRL+S)を押すたびに、ワークスペース・データベースが同期され、更新されたモデル・メタデータがディスクに保存し直されます。この方法の利点は、Tabular EditorがAnalysis Servicesに接続されているため、以下の[接続された機能](#connected-features)が利用でき、またディスク上のソースファイルを簡単に更新することができる点です。Tabular Editor 2.xでは、データベースからモデルを開き、たまに手動でディスクに保存することを忘れないようにしなければなりませんでした。
+
+このアプローチは[並行開発](xref:parallel-development)やバージョン管理システムとのモデルメタデータの統合を可能にするために理想的なものです。
+
+詳しくはを参照してください。
+
+### 接続された機能
+
+Tabular Editor 3には新しい接続機能が多数含まれており、Analysis Servicesのクライアントツールとして使用することができます。これらの機能は、Tabular Editor 3が直接または[ワークスペース・モード](#workspace-mode)機能を使用してAnalysis Servicesに接続されたときに有効になります。
+
+新たに接続された機能は以下の通りです。
+
+- テーブルデータのプレビュー
+- ピボットグリッド
+- DAXクエリ
+- データリフレッシュ操作
+- VertiPaq Analyzer
+
+### ダイアグラム
+
+Tabular Editor 2.xで要望の多かった機能の1つは、テーブル間のリレーションシップをより良く可視化することでした。Tabular Editor 3 では、モデル図を作成できるようになりました。各ダイアグラムは、ダイアグラムに含まれるテーブルの名前と座標を保持するシンプルなJSONファイルです。そして、Tabular Editor 3はテーブルとリレーションシップをレンダリングし、リレーションシップの編集や既存のリレーションシップに基づくテーブルの追加などを簡単に行う機能を提供します。
+
+
+
+詳しくは、[ダイアグラムを使った作業](xref:importing-tables-data-modeling#working-with-diagrams)を参照してください。
+
+### C# スクリプトとマクロレコーダー
+
+Tabular Editor 2.xの**Advanced Scripting**機能は、**C# Scripts**としてTabular Editor 3に引き継がれました。Tabular Editor 3での重要な違いの1つは、1つのスクリプトでの作業に制限されなくなったことです。その代わり、**File > New > C# Script** オプションを使用すると、必要な数のC#スクリプトを作成し、作業できます。Tabular Editor 2.xと同様に、これらのスクリプトは再利用可能なアクションとして保存でき、TOM Explorerの右クリックのコンテキストメニューに直接統合されます。Tabular Editor 3ではこれらのアクションを **Macros** と呼び、マクロを追加できる独自のメニューやツールバーを作成することも可能です。
+
+もっとも重要なのは、Tabular Editor 3には**マクロレコーダー**があり、ユーザーのインタラクションからC#コードを自動的に生成するために使用することができることです。
+
+> [!注意]。
+> この記事の執筆時点では、Tabular Editor 3のC#スクリプトエディターにはIntelliSenseのような機能は含まれていません。これは後日リリースされる予定です。
+
+詳しくは@cs-scripts-and-macrosを参照してください。
+
+### DAX スクリプト
+
+Tabular Editor 2.xから来た人が知っておくべき最後の重要な機能は**DAX Scripting**です。この機能により、複数の計算オブジェクトのDAX式と基本プロパティを一度に編集できるドキュメントを作成できます。計算オブジェクトとは、メジャー、計算カラム、計算テーブルなどです。
+
+これは、複数のオブジェクトにまたがる複雑なビジネスロジックをオーサリングする際に非常に便利です。TOM Explorerでオブジェクトを（複数）選択し、右クリックして**Script DAX**オプションを選択すると、選択されたすべてのオブジェクトの定義を含む新しいDAXスクリプトが得られます。DAXスクリプトエディターは、エクスプレッションエディターやDAXクエリエディターと同じDAX機能をもちろん持っています。
+
+DAXスクリプトは、**コネクテッド**モードまたは**ワークスペース**モードで作業する場合、更新されたビジネスロジックをすばやく修正およびテストするための非常に強力なツールです（たとえば、下のスクリーンショットに示すようにピボットグリッドと組み合わせて使用する場合など）。SHIFT+F5を押すだけで、スクリプト内のDAX式に基づいてデータベースが更新され、その後、ピボット・グリッドが即座に更新されます。
+
+
+
+詳しくは、@dax-script-introductionをご覧ください。
diff --git a/onboarding/ja-jp/ja-migrate-from-vs.md b/onboarding/ja-jp/ja-migrate-from-vs.md
new file mode 100644
index 0000000..64e49a0
--- /dev/null
+++ b/onboarding/ja-jp/ja-migrate-from-vs.md
@@ -0,0 +1,209 @@
+---
+uid: migrate-from-vs
+title: Migrating from Visual Studio
+author: Daniel Otykier
+updated: 2021-09-30
+---
+
+# Migrating from Visual Studio / SQL Server Data Tools
+
+This article assumes that you are familiar with Tabular model development using [Analysis Services Projects for Visual Studio](https://marketplace.visualstudio.com/items?itemName=ProBITools.MicrosoftAnalysisServicesModelingProjects) (formerly known as SQL Server Data Tools). This is common among developers using SQL Server Analysis Services (Tabular) or Azure Analysis Services.
+
+- If you have never used Visual Studio for Tabular model development, you can safely skip this topic.
+- If you previously used Tabular Editor 2.x for Tabular model development, we recommend you skip directly to the @migrate-from-te2 article.
+
+## Partial migration
+
+Tabular Editor 3 contains features that allow you to completely migrate away from Visual Studio for tabular model development. This is in contrast to Tabular Editor 2.x, where some users still preferred using Visual Studio for things like table import, visualization of relationships and preview of data.
+
+However, as you familiarize yourself with Tabular Editor 3, you might still find it useful to open your tabular models in Visual Studio from time to time. This is possible at any time, since Tabular Editor 3 does not modify the **Model.bim** file format (aka. the [TOM JSON](https://docs.microsoft.com/en-us/analysis-services/tom/introduction-to-the-tabular-object-model-tom-in-analysis-services-amo?view=asallproducts-allversions)) used by Visual Studio, thus ensuring compatibility with Visual Studio.
+
+The only exception is, if you decide to use Tabular Editor's [Save-to-folder](xref:parallel-development#what-is-save-to-folder) feature, as this file format is not supported by Visual Studio. However, you can easily recreate a Model.bim file for use with Visual Studio, using the **File > Save As...** option in Tabular Editor. The opposite conversion can also be performed by loading a Model.bim file in Tabular Editor and then using the **File > Save to Folder...** option.
+
+### Automating file format conversion
+
+If you often face the need to convert back and forth between Tabular Editor's (database.json) folder-based format and Visual Studio's (model.bim) file format, consider writing a small Windows command script using [Tabular Editor 2.x CLI](xref:command-line-options) to automate the conversion process.
+
+# [Model.bim to folder](#tab/frombim)
+
+To convert from model.bim to database.json (folder-based format):
+```cmd
+tabulareditor.exe model.bim -F database.json
+```
+
+# [Folder to model.bim](#tab/fromfolder)
+
+To convert from database.json (folder-based format) to model.bim:
+```cmd
+tabulareditor.exe database.json -B model.bim
+```
+
+***
+
+> [!NOTE]
+> The command line script above assumes you have [Tabular Editor 2.x](xref:getting-started-te2) installed. The installation location of Tabular Editor 2.x should also be specified as part of your [PATH environment variable](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/path).
+
+## Integrated Workspace server
+
+When starting a new Analysis Services (Tabular) project in Visual Studio, you are prompted to choose if you want to use Visual Studio's Integrated workspace server or provide your own instance of Analysis Services. In addition, you must decide the compatibility level of the tabular model (see screenshot below).
+
+
+
+In contrast, when creating a new model in Tabular Editor, using a workspace server is completely optional (but recommended - see [workspace mode](xref:workspace-mode)).
+
+Below is the dialog box shown when creating a new model in Tabular Editor 3:
+
+
+
+If you enable the **Use workspace database** option, Tabular Editor will prompt you for an Analysis Services instance and database name that will be used as as workspace database while working on the model. If you do not enable this option, you will be able to create and work on your model in "offline" mode, which still allows you to add tables, relationships, author DAX expressions, etc. However, you will have to deploy your offline model to an instance of Analysis Services before you can refresh, preview and query the data in the model.
+
+> [!IMPORTANT]
+> Tabular Editor 3 does not provide a feature equivalent to the **Integrated workspace** option of Visual Studio. Essentially, the integrated workspace is an Analysis Services instance managed by Visual Studio. Since Analysis Services is proprietary software from Microsoft, we cannot ship it alongside Tabular Editor 3. Instead, if you would like to run a local instance of Analysis Services for use with Tabular Editor, we recommend that you install [SQL Server Developer Edition](https://www.microsoft.com/en-us/sql-server/sql-server-downloads).
+
+### Compatibility level requirements
+
+Tabular Editor lets you choose the following compatibility levels for creating Analysis Services databases:
+
+- 1200 (Azure Analysis Services / SQL Server 2016+)
+- 1400 (Azure Analysis Services / SQL Server 2017+)
+- 1500 (Azure Analysis Services / SQL Server 2019+)
+
+In addition, Tabular Editor lets you choose compatibility levels suitable for Power BI datasets that will be deployed to the Power BI service through the [XMLA endpoint](xref:powerbi-xmla).
+
+> [!NOTE]
+> Tabular Editor does not support compatibility levels below 1200, as these do not use the [Tabular Object Model (TOM)](https://docs.microsoft.com/en-us/analysis-services/tom/introduction-to-the-tabular-object-model-tom-in-analysis-services-amo?view=asallproducts-allversions) metadata format. If you plan on migrating development from Visual Studio to Tabular Editor for a model in compatibility level 1100 or 1103, **you must upgrade the compatibility level to at least 1200** before migrating to Tabular Editor. By doing so, you will no longer be able to deploy the model to SQL Server 2014 Analysis Services.
+
+## Visual Studio projects
+
+When creating an Analysis Services (Tabular) project in Visual Studio, a number of files are created in the project folder next to the Model.bim file. These files contain project- and user-specific information which is not related to the Tabular Object Model (TOM). The screenshot below shows the files resulting from creating a new tabular project in Visual Studio.
+
+
+
+When migrating to Tabular Editor, you only need to bring the Model.bim file, as the concept of "project" does not exist here. Instead, Tabular Editor simply loads the model metadata directly from the Model.bim file. In some cases, a file called the [Tabular Model User Options (tmuo) file](xref:user-options) is created next to the Model.bim file. This file is used by Tabular Editor to store user- and model specific settings, such as whether or not to use a workspace database, (encrypted) user credentials for data sources, etc.
+
+To keep the "project" directory clean, we therefore recommend to copy the Model.bim file created by Visual Studio into a new directory, before loading the file in Tabular Editor.
+
+
+
+If you want to use the [Save-to-folder](xref:parallel-development#what-is-save-to-folder) feature, which is recommended for parallel development and integration with version control systems, now is the time to save the model as a folder from within Tabular Editor (**File > Save To Folder...**).
+
+
+
+## Version control
+
+Tabular Editor does not have any integrated version control of model metadata. However, since all model metadata is stored as simple text (JSON) files on the disk, it is straightforward to include the tabular model metadata in any type of version control system. For this reason, most Tabular Editor users prefer to still keep Visual Studio installed, in order to have access to the [Visual Studio Team Explorer](https://docs.microsoft.com/en-us/azure/devops/user-guide/work-team-explorer?view=azure-devops) or, specifically for git, the new [Git Changes window](https://docs.microsoft.com/en-us/visualstudio/version-control/git-with-visual-studio?view=vs-2019) of Visual Studio 2019.
+
+> [!NOTE]
+> These days, it seems that [git](https://git-scm.com/) is the preferred version control system by most developers. Git integration in Tabular Editor 3 is planned for a future update.
+
+Once you migrate to Tabular Editor, you do not need to keep the original Tabular model project and supporting files created by Visual Studio. You can still use the Visual Studio Team Explorer or Git Changes window to look at code changes, manage version control branches, perform code check-ins, merges, etc.
+
+Of course, most version control systems also have their own set of tools that you can use without relying on Visual Studio. For example, git has its command line and many popular tools that integrate directly with the Windows Explorer, such as [TortoiseGit](https://tortoisegit.org/).
+
+### Save-to-folder and version control
+
+The main advantage of using the [Save-to-folder](xref:parallel-development#what-is-save-to-folder) option, is that the model metadata is broken out into multiple small files, instead of storing everything in a large JSON document. Many properties in the TOM are arrays of objects (for example tables, measures and columns). Since all such objects have explicit names, their order in the array does not matter. Sometimes it happens that the order is changed during serialization to JSON, and this causes most version control system to indicate that a change was made to the file. However, since this ordering does not have any semantic meaning, we should not bother handling merge conflicts that may arise from this type of change.
+
+With Save-to-folder serialization, the number of arrays used in the JSON files are greatly reduced, as objects that would otherwise be stored as arrays, are now broken out into individual files stored within a subfolder. When Tabular Editor loads the model metadata from disk, it traverses all these subfolders to ensure all objects are deserialized correctly into the TOM.
+
+As such, Save-to-folder serialization greatly reduces the chance that merge conflicts are ever encountered, when two or more developers make parallel changes to the same tabular model.
+
+## UI differences
+
+This section lists the most important differences between the user interfaces of Tabular Editor 3 and Visual Studio for tabular model development. If you are an avid Visual Studio user, you should feel quite comfortable with Tabular Editor 3's user interface. If you would like a more detailed walkthrough, please see .
+
+### Tabular Model Explorer vs. TOM Explorer
+
+In Visual Studio, a hierarchical overview of the model metadata can be found in the **Tabular Model Explorer**.
+
+
+
+In Tabular Editor, this is called the **TOM Explorer** view. In Tabular Editor, all data modeling generally revolves around locating the relevant objects in the TOM Explorer and then performing certain actions by invoking the right-click context menu, by navigating to the main menu, or by editing object properties in the **Properties** view. In Tabular Editor, you can use intuitive operations such as multi-select, drag-drop, copy-paste and undo-redo for all data modeling operations.
+
+
+
+The TOM Explorer in Tabular Editor also has shortcut options for showing/hiding certain types of objects, hidden objects, display folders, and for quickly searching and filtering the metadata hierarchy.
+
+See @tom-explorer-view for more information.
+
+### Property Grid
+
+Both Visual Studio and Tabular Editor include a property grid that allows you to edit most object properties of whatever object is currently selected. Below is a comparison between the Visual Studio property grid (left) and the Tabular Editor property grid (right) for the same measure:
+
+
+
+The two generally work the same way, except that Tabular Editor uses property names that are closely aligned with the TOM object properties. Tabular Editor also adds a number of properties that are not found in the TOM, to make certain modeling operations easier. For example, by expanding the **Translated Names** property, you can compare and edit object name translations across all model cultures.
+
+### Editing DAX expressions
+
+In Visual Studio, you can use the formula bar or open a DAX editor window by right-clicking on a measure in the Tabular Model Explorer and choosing "Edit formula".
+
+Tabular Editor works quite similar, with the formula bar being replaced by the **Expression Editor** view. In addition, if you want to edit the DAX expressions for one or more objects in a standalone document, you can right-click on those objects (measures, calculated columns, calculated tables), and choose **Script DAX**.
+
+The DAX code editor in Tabular Editor 3 is one of the main reasons for using the tool. You can read more about it [here](xref:dax-editor).
+
+### Error List vs. Messages View
+
+In Visual Studio, DAX syntax errors are shown as warnings within the **Error List** (see screenshot below). In addition, measures that have errors are indicated with a warning triangle in the measures grid.
+
+
+
+In Tabular Editor, we use the Messages View to consolidate all error, warning and informational messages posted by different sources during model development. Specifically for DAX syntax errors, these are shown as errors in the Messages View, and any measures that have an error are indicated with a red dot in the TOM Explorer (see screenshot below).
+
+
+
+In the screenshot above, notice how there are three different message-posting sources:
+
+- **Analysis Services**: When metadata changes are saved to a connected instance of Analysis Services, the server updates the TOM metadata to indicate if any objects are in an erroneous state. Specifically, the [State](https://docs.microsoft.com/en-us/dotnet/api/microsoft.analysisservices.tabular.measure.state?view=analysisservices-dotnet#Microsoft_AnalysisServices_Tabular_Measure_State) and [ErrorMessage](https://docs.microsoft.com/en-us/dotnet/api/microsoft.analysisservices.tabular.measure.errormessage?view=analysisservices-dotnet#Microsoft_AnalysisServices_Tabular_Measure_ErrorMessage) properties are updated. Tabular Editor displays these error messages in the Messages View. These messages are not shown when Tabular Editor is used offline (i.e. without a connection to Analysis Services).
+- **Tabular Editor Semantic Analysis**: In addition, Tabular Editor 3 performs its own semantic analysis of all DAX expressions in the model. Any syntax or semantic errors encountered are reported here.
+- **Expression Editor**: Lastly, if any documents are open in Tabular Editor 3, such as the Expression Editor, any DAX syntax or semantic errors encountered in the document are reported here.
+
+### Previewing table data
+
+In Visual Studio, tables and their content are displayed in a tabbed view once you load the Model.bim file. In Tabular Editor 3, you can preview table data by right-clicking on a table in the TOM Explorer, and chooseing **Preview Data**. This opens a new document tab that lets you scroll through all rows of the table, as well as filter and sort the columns. It even works for model using DirectQuery!
+
+Also, you can freely rearrange the documents, to view the content of several tables at once (see screenshot below).
+
+
+
+### Importing tables
+
+To import new tables with Tabular Editor 3, use the **Model > Import tables...** option. This launches Tabular Editor 3's Import Table Wizard, which guides you through the process of connecting to a data source and selecting tables to import. The process is relatively similar to the legacy table import in Visual Studio.
+
+One important difference is that Tabular Editor 3 does not include a visual Power Query Editor. You can still edit Power Query (M) expressions as text, but if your model relies heavily on complex data transformation expressed as Power Query queries, you should consider to keep using Visual Studio for purposes of editing the Power Query queries.
+
+> [!NOTE]
+> Performing complex data transformations using Power Query is generally not recommended for enterprise data modeling, due to the increased overhead of data refresh operations. Instead, prepare your data into a star schema using other ETL tools, and store the star schema data in a relational database, such as SQL Server or Azure SQL Database. Then, import tables to your tabular model from that database.
+
+#### Editing partitions and updating table schema
+
+In Tabular Editor 3, you can update the schema of a table without forcing a table refresh. Partitions are displayed in the TOM Explorer as individual objects. Click on a partition to edit its expression (M or SQL) in the Expression Editor.
+
+Once a partition expression has been updated, Tabular Editor can automatically detect if the table schema resulting from the updated expression, is different from the set of columns defined in the model. To perform a schema update, right-click on the partition or table in the TOM Explorer and choose **Update table schema...**.
+
+For more information about table import and schema updates, see @importing-tables.
+
+### Visualizing relationships
+
+Visual Studio includes a diagram tool that lets you visualize and create relationships between tables.
+
+Tabular Editor 3 also includes a diagram tool, that can be accessed using **File > New > Diagram**. A new diagram document tab will be created, at which point you can add tables from the TOM Explorer by dragging and dropping, or from the **Diagram > Add tables...** menu.
+
+Once tables have been added to the diagram, you can create relationship between columns simply by dragging from one column to another.
+
+
+
+> [!NOTE]
+> For performance reasons, the diagram tool does not inspect the data of the model, nor does it validate the uniqueness or directionality of any relationships you create. It is up to you to ensure that relationships are created correctly. If a relationship has been incorrectly defined, Analysis Services will return an error state which is shown in the **Messages View**.
+
+### Model deployment
+
+Tabular Editor lets you easily deploy the model metadata to any instance of Analysis Services. You can invoke Tabular Editor's Deployment Wizard under **Model > Deploy...** or by hitting CTRL+SHIFT+D.
+
+For more information, see .
+
+## Next steps
+
+- @migrate-from-te2
+- @parallel-development
+- @boosting-productivity-te3
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-optimizing-workflow-workspace-mode.md b/onboarding/ja-jp/ja-optimizing-workflow-workspace-mode.md
new file mode 100644
index 0000000..d43b6f0
--- /dev/null
+++ b/onboarding/ja-jp/ja-optimizing-workflow-workspace-mode.md
@@ -0,0 +1,21 @@
+---
+uid: optimizing-workflow-workspace-mode
+title: Optimizing development workflow using Workspace Mode
+author: Daniel Otykier
+updated: 2021-10-05
+applies_to:
+ editions:
+ - edition: Desktop
+ none: x
+ - edition: Business
+ - edition: Enterprise
+---
+
+# Optimizing development workflow using Workspace Mode
+[!include[workspace-mode](~/te3/workspace-mode.partial.md)]
+
+# Next steps
+
+- @powerbi-cicd
+- @as-cicd
+- @boosting-productivity-te3
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-parallel-development.md b/onboarding/ja-jp/ja-parallel-development.md
new file mode 100644
index 0000000..114cdf6
--- /dev/null
+++ b/onboarding/ja-jp/ja-parallel-development.md
@@ -0,0 +1,187 @@
+---
+uid: parallel-development
+title: Enabling parallel development using Git and Save to Folder
+author: Daniel Otykier
+updated: 2021-09-30
+applies_to:
+ editions:
+ - edition: Desktop
+ none: x
+ - edition: Business
+ - edition: Enterprise
+---
+
+# Enabling parallel development using Git and Save to Folder
+
+
+
+This article describes the principles of parallel model development (that is, the ability for multiple developers to work in parallel on the same data model) and the role of Tabular Editor in this regard.
+
+# Prerequisites
+
+- The destination of your data model must be one of the following:
+ - SQL Server 2016 (or newer) Analysis Services Tabular
+ - Azure Analysis Services
+ - Power BI Premium Capacity/Power BI Premium-per-user with [XMLA read/write enabled](https://docs.microsoft.com/en-us/power-bi/admin/service-premium-connect-tools#enable-xmla-read-write)
+- Git repository accessible by all team members (on-premises or hosted in Azure DevOps, GitHub, etc.)
+
+# TOM as source code
+
+Parallel development has traditionally been difficult to implement on Analysis Services tabular models and Power BI datasets (in this article, we will call both types of models "tabular models" for brevity). With the introduction of the JSON-based model metadata used by the [Tabular Object Model (TOM)](https://docs.microsoft.com/en-us/analysis-services/tom/introduction-to-the-tabular-object-model-tom-in-analysis-services-amo?view=asallproducts-allversions), integrating model metadata in version control has certainly become easier.
+
+The use of a text-based file format makes it possible to handle conflicting changes in a graceful way, by using various diff tools that are often included with the version control system. This type of change conflict resolution is very common in traditional software development, where all of the source code resides in a large number of small text files. For this reason, most popular version control systems are optimized for these types of files, for purposes of change detection and (automatic) conflict resolution.
+
+For tabular model development, the "source code" is our JSON-based TOM metadata. When developing tabular models with earlier versions of Visual Studio, the Model.bim JSON file was augmented with information about who modified what and when. This information was simply stored as additional properties on the JSON objects throughout the file. This was problematic, because not only was the information redundant (since the file itself also has metadata that describes who the last person to edit it was, and when the last edit happened), but from a version control perspective, this metadata does not hold any *semantic meaning*. In other words, if you were to remove all of the modification metadata from the file, you would still end up with a perfectly valid TOM JSON-file, that you could deploy to Analysis Services or publish to Power BI, without affecting the functionality and business logic of the model.
+
+Just like source code for traditional software development, we do not want this kind of information to "contaminate" our model metadata. Indeed, a version control system gives a much more detailed view of the changes that were made, who made them, when and why, so there is no reason to include it as part of the files being versioned.
+
+When Tabular Editor was first created, there was no option to get rid of this information from the Model.bim file created by Visual Studio, but that has luckily changed in more recent versions. However, we still need to deal with a single, monolithic file (the Model.bim file) containing all of the "source code" that defines the model.
+
+Power BI dataset developers have it much worse, since they do not even have access to a text-based file containing the model metadata. The best they can do is export their Power BI report as a [Power BI Template (.pbit) file](https://docs.microsoft.com/en-us/power-bi/create-reports/desktop-templates#creating-report-templates) which is basically a zip file containing the report pages, the data model definitions and the query definitions. From the perspective of a version control system, a zip file is a binary file, and binary files cannot be diff'ed, compared and merged, the same way text files can. This forces Power BI developers to use 3rd party tools or come up with elaborate scripts or processes for properly versioning their data models - especially, if they want to be able to merge parallel tracks of development within the same file.
+
+Tabular Editor aims to simplify this process by providing an easy way to extract only the semantically meaningful metadata from the Tabular Object Model, regardless of whether that model is an Analysis Services tabular model or a Power BI dataset. Moreover, Tabular Editor can split up this metadata into several smaller files using its Save to Folder feature.
+
+# What is Save to Folder?
+
+As mentioned above, the model metadata for a tabular model is traditionally stored in a single, monolithic JSON file, typically named **Model.bim**, which is not well suited for version control integration. Since the JSON in this file represents the [Tabular Object Model (TOM)](https://docs.microsoft.com/en-us/analysis-services/tom/introduction-to-the-tabular-object-model-tom-in-analysis-services-amo?view=asallproducts-allversions), it turns out that there is a straight forward way to break the file down into smaller pieces: The TOM contains arrays of objects at almost all levels, such as the list of tables within a model, the list of measures within a table, the list of annotations within a measure, etc. When using Tabular Editor's **Save to Folder** feature, these arrays are simply removed from the JSON, and instead, a subfolder is generated containing one file for each object in the original array. This process can be nested. The result is a folder structure, where each folder contains a set of smaller JSON files and subfolders, which semantically contains exactly the same information as the original Model.bim file:
+
+
+
+The names of each of the files representing individual TOM objects are simply based on the `Name` property of the object itself. The name of the "root" file is **Database.json**, which is why we sometimes refer to the folder-based storage format as simply **Database.json**.
+
+## Pros of using Save to Folder
+
+Below are some of the advantages of storing the tabular model metadata in this folder based format:
+
+- **Multiple smaller files work better with many version control systems than few large files.** For example, git stores snapshots of modified files. For this reason alone, it makes sense why representing the model as multiple smaller files is better than storing it as a single, large file.
+- **Avoid conflicts when arrays are reordered.** Lists of tables, measures, columns, etc., are represented as arrays in the Model.bim JSON. However, the order of objects within the array does not matter. It is not uncommon for objects to be reordered during model development, for example due to cut/paste operations, etc. With Save to Folder, array objects are stored as individual files, so the arrays are no longer change tracked, reducing the risk of merge conflicts.
+- **Different developers rarely change the same file.** As long as developers work on separate parts of the data model, they will rarely make changes to the same files, reducing the risk of merge conflicts.
+
+## Cons of using Save to Folder
+
+As it stands, the only disadvantage of storing the tabular model metadata in the folder based format, is that this format is used exclusively by Tabular Editor. In other words, you can not directly load the model metadata into Visual Studio from the folder based format. Instead, you would have to temporarily convert the folder based format to the Model.bim format, which can of course be done using Tabular Editor.
+
+## Configuring Save to Folder
+
+One size rarely fits all. Tabular Editor has a few configuration options that affect how a model is serialized into the folder structure. In Tabular Editor 3, you can find the general settings under **Tools > Preferences > Save-to-folder**. Once a model is loaded in Tabular Editor, you can find the specific settings that apply to that model under **Model > Serialization options...**. The settings that apply to a specific model are stored as an annotation within the model itself, to ensure that the same settings are used regardless of which user loads and saves the model.
+
+
+
+### Serialization settings
+
+- **Use recommended settings**: (Default: checked) When this is checked, Tabular Editor uses the default settings when saving a model as a folder structure for the first time.
+- **Serialize relationships on from-tables**: (Default: unchecked) When this is checked, Tabular Editor stores relationships as an annotation on the table at the "from-side" (typically the fact table) of the relationship, instead of storing them at the model level. This is useful when in the early development phase of a model, where table names are still subject to change quite often.
+- **Serialize perspective membership info on objects**: (Default: unchecked) When this is checked, Tabular Editor stores information about which perspectives an object (table, column, hierarchy, measure) belongs to, as an annotation on that object, instead of storing the information at the perspective level. This is useful when object names are subject to change, but perspective names are finalised.
+- **Serialize translations on translated objects**: (Default: unchecked) When this is checked, Tabular Editor stores metadata translations as an annotation on each translatable object (table, column, hierarchy, level, measure, etc.), instead of storing the translations at the culture level. This is useful when object names are subject to change.
+- **Prefix file names sequentially**: (Default: unchecked) In cases where you want to retain the metadata ordering of array members (such as the order of columns in a table), you can check this to have Tabular Editor prefix the filenames with a sequential integer based on the object's index in the array. This is useful if you use the default drillthrough feature in Excel, and would like [columns to appear in a certain order in the drillthrough](https://github.com/TabularEditor/TabularEditor/issues/46#issuecomment-297932090).
+
+> [!NOTE]
+> The main purpose of the settings described above, is to reduce the number of merge conflicts encountered during model development, by adjusting how and where certain model metadata is stored. In the early phases of model development, it is not uncommon for objects to be renamed often. If a model already has metadata translations specified, every object rename would cause at least two changes: One change on the object being renamed, and one change for every culture that defines a translation on that object. When **Serialize translations on translated objects** is checked, there would only be a change on the object being renamed, as that object also includes the translated values (since this information would be stored as an annotation).
+
+### Serialization depth
+
+The checklist allows you to specify which objects will be serialized as individual files. Note that some options (perspectives, translations, relationships) may not be available, depending on the settings specified above.
+
+In most cases, it is recommended to always serialize objects to the lowest level. However, there may be special cases where this level of detail is not needed.
+
+# Power BI and version control
+
+As mentioned above, integrating a Power BI report (.pbix) or Power BI template (.pbit) file in version control, does not enable parallel development or conflict resolution, due to these files using a binary file format. At the same time, we have to be aware of the current limitations of using Tabular Editor (or other third party tools) with Power BI Desktop or the Power BI XMLA endpoint respectively.
+
+These limitations are:
+
+- When using Tabular Editor as an external tool for Power BI Desktop, [not all modeling operations are supported](@xref:desktop-limitations).
+- Tabular Editor can extract model metadata from a .pbix file loaded in Power BI Desktop, or directly from a .pbit file on disk, but there is **no supported way to update model metadata in a .pbix or .pbit file outside of Power BI Desktop**.
+- Once any changes are made to a Power BI dataset through the XMLA endpoint, [that dataset can no longer be downloaded as a .pbix file](https://docs.microsoft.com/en-us/power-bi/admin/service-premium-connect-tools#power-bi-desktop-authored-datasets).
+
+To enable parallel development, we must be able to store the model metadata in one of the text-based (JSON) formats mentioned above (Model.bim or Database.json). There is no way to "recreate" a .pbix or .pbit file from the text-based format, so **once we decide to go this route, we will no longer be able to use Power BI Desktop for editing the data model**. Instead, we will have to rely on tools that can use the JSON-based format, which is exactly the purpose of Tabular Editor.
+
+> [!WARNING]
+> If you do not have access to a Power BI Premium workspace (either Premium capacity or Premium-Per-User), you will not be able to publish the model metadata stored in the JSON files, since this operation requires access to the [XMLA endpoint](https://docs.microsoft.com/en-us/power-bi/admin/service-premium-connect-tools).
+
+> [!NOTE]
+> Power BI Desktop is still needed for purpose of creating the visual part of the report. It is a [best practice to always separate reports from models](https://docs.microsoft.com/en-us/power-bi/guidance/report-separate-from-model). In case you have an existing Power BI file that contains both, [this blog post](https://powerbi.tips/2020/06/split-an-existing-power-bi-file-into-a-model-and-report/) ([video](https://www.youtube.com/watch?v=PlrtBm9YN_Q)) describes how to split it into a model file and a report file.
+
+# Tabular Editor and git
+
+Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. It is the most popular version control system right now, and it is available through multiple hosted options, such as [Azure DevOps](https://azure.microsoft.com/en-us/services/devops/repos/), [GitHub](https://github.com/), [GitLab](https://about.gitlab.com/) and others.
+
+A detailed description of git is outside the scope of this article. There are, however, many resources available online if you want to learn more. We recommend the [Pro Git](https://git-scm.com/book/en/v2) book for reference.
+
+> [!NOTE]
+> Tabular Editor 3 does not currently have any integration with git or other version control systems. To manage your git repository, commit code changes, create branches, etc., you will have to use the git command line or another tool, such as the [Visual Studio Team Explorer](https://docs.microsoft.com/en-us/azure/devops/user-guide/work-team-explorer?view=azure-devops#git-version-control-and-repository) or [TortoiseGit](https://tortoisegit.org/).
+
+As mentioned earlier, we recommend using Tabular Editor's [Save to Folder](#what-is-save-to-folder) option when saving model metadata to a git code repository.
+
+## Branching strategy
+
+What follows is a discussion of branching strategies to employ when developing tabular models.
+
+The branching strategy will dictate what the daily development workflow will be like, and in many cases, branches will tie directly into the project methods used by your team. For example, using the [agile process within Azure DevOps](https://docs.microsoft.com/en-us/azure/devops/boards/work-items/guidance/agile-process-workflow?view=azure-devops), your backlog would consist of **Epics**, **Features**, **User Stories**, **Tasks** and **Bugs**.
+
+In the agile terminology, a **User Story** is a deliverable, testable piece of work. The User Story may consist of several **Tasks**, that are smaller pieces of work that need to be performed, typically by a developer, before the User Story may be delivered. In the ideal world, all User Stories have been broken down into manageable tasks, each taking only a couple of hours to complete, adding up to no more than a handful of days for the entire User Story. This would make a User Story an ideal candidate for a so-called Topic Branch, where the developer could make one or more commits for each of the tasks within the User Story. Once all tasks are done, you want to deliver the User Story to the client, at which time the topic branch is merged into a delivery branch (for example, a "Test" branch), and the code deployed to a testing environment.
+
+Determining a suitable branching strategy depends on many different factors. In general, Microsoft recommends the [Trunk-based Development](https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops) ([video](https://youtu.be/t_4lLR6F_yk?t=232)) strategy, for agile and continuous delivery of small increments. The main idea is to create branches off the "Main" branch for every new feature or bugfix (see image below). Code review processes are enforced through pull requests from feature branches into Main, and using the Branch Policy feature of Azure DevOps, we can set up rules that require code to build cleanly before a pull request can be completed.
+
+
+
+### Trunk-based Development
+
+However, such a strategy might not be feasible in a Business Intelligence development teams, for a number of reasons:
+
+- New features often require prolonged testing and validation by business users, which may take several weeks to complete. As such, you will likely need a user-faced test environment.
+- BI solutions are multi-tiered, typically consisting of a Data Warehouse tier with ETL, a Master Data Management tier, a semantic layer and reports. Dependencies exist between these layers, that further complicate testing and deployment.
+- The BI team may be responsible for developing and maintaining several different semantic models, serving different areas of business (Sales, Inventory, Logistics, Finance, HR, etc.), at different maturity stages and at varying development pace.
+- The most important aspect of a BI solution is the data! As a BI developer, you don not have the luxury of simply checking out the code from source control, hitting F5 and having a full solution up and running in the few minutes it takes to compile the code. Your solution needs data, and that data has to be loaded, ETL'ed or processed across several layers to make it to the end user. Including data in your DevOps workflows could blow up build and deployment times from minutes to hours or even days. In some scenarios, it might not even be possible, due to ressource or economy constraints.
+
+There is no doubt that a BI team would benefit from a branching strategy that supports parallel development on any of the layers in the full BI solution, in a way that lets them mix and match features that are ready for testing. But especially due to the last bullet point above, we need to think carefully about how we are going to handle the data. If we add a new attribute to a dimension, for example, do we want to automatically load the dimension as part of our build and deployment pipelines? If it only takes a few minutes to load such a dimension, that would probably be fine, but what if we are adding a new column to a multi-billion row fact table? And if developers are working on new features in parallel, should each developer have their own development database, or how do we otherwise prevent them from stepping on each others toes in a shared database?
+
+There is no easy answer to the questions above - especially when considering all the tiers of a BI solution, and the different constellations and prefered workflows of BI teams across the planet. Also, when we dive into actual build, deployment and test automation, we are going to focus mostly on Analysis Services. The ETL- and database tiers have their own challenges from a DevOps perspective, which are outside the scope of this article. But before we move on, let us take a look at another branching strategy, and how it could potentially be adopted to BI workflows.
+
+### GitFlow branching and deployment environments
+
+The strategy described below is based on [GitFlow by Vincent Driessen](https://nvie.com/posts/a-successful-git-branching-model/).
+
+
+
+Implementing a branching strategy similar to this, can help solve some of the DevOps problems typically encountered by BI teams, provided you put some thought into how the branches correlate to your deployment environments. In an ideal world, you would need at least 4 different environments to fully support GitFlow:
+
+- The **production** environment, which should always contain the code at the HEAD of the master branch.
+- A **canary** environment, which should always contain the code at the HEAD of the develop branch. This is where you typically schedule nightly deployments and run your integration testing, to make sure that the features going into the next release to production play nicely together.
+- One or more **UAT** environments where you and your business users test and validate new features. Deployment happens directly from the feature branch containing the code that needs to be tested. You will need multiple test environments if you want to test multiple new features in parallel. With some coordination effort, a single test environment is usually enough, as long as you carefully consider the dependencies between your BI tiers.
+- One or more **sandbox** environments where you and your team can develop new features, without impacting any of the environments above. As with the test environment, it is usually enough to have a single, shared, sandbox environment.
+
+We must emphasize that there is really no "one-size-fits-all" solution to these considerations. Maybe you are not building your solution in the Cloud, and therefore do not have the scalability or flexibility to spin up new resources in seconds or minutes. Or maybe your data volumes are very large, making it impractical to replicate environments due to resource/economy/time constraints. Before moving on, also make sure to ask yourself the question of whether you truly need to support parallel development and testing. This is rarely the case for small teams with only a few stakeholders, in which case you can still benefit from CI/CD, but where GitFlow branching might be overkill.
+
+Even if you do need to support parallel development, you may find that multiple developers can easily share the same development or sandbox environment, without encountering too much trouble. Specifically for tabular models, though, we recommend that developers still use individual [workspace databases](xref:workspace-mode) to avoid "stepping over each others toes".
+
+## Common workflow
+
+Assuming you already have a git repository set up and aligned to your branching strategy, adding your tabular model "source code" to the repository is simply a matter of using Tabular Editor to save the metadata to a new branch in a local repository. Then, you stage and commit the new files, push your branch to the remote repository and create a pull request to get your branch merged into the main branch.
+
+The exact workflow depends on your branching strategy and how your git repositories have been set up. In general, the workflow would look something like this:
+
+1. Before starting work on a new feature, create a new feature branch in git. In a trunk-based development scenario, you would need the following git commands to checkout the main branch, get the latest version of the code, and create the feature branch from there:
+ ```cmd
+ git checkout main
+ git pull
+ git checkout -b "feature\AddTaxCalculation"
+ ```
+2. Open your model metadata from the local git repository in Tabular Editor. Ideally, use a [workspace database](xref:workspace-mode), to make it easier to test and debug DAX code.
+3. Make the necessary changes to your model using Tabular Editor. Continuously save the changes (CTRL+S). Regularly commit code changes to git after you save, to avoid losing work and to keep a full history of all changes that were made:
+ ```cmd
+ git add .
+ git commit -m "Description of what was changed and why since last commit"
+ git push
+ ```
+4. If you are not using a workspace database, use Tabular Editor's **Model > Deploy...** option to deploy to a sandbox/development environment, in order to test the changes made to the model metadata.
+6. When done, and all code has been committed and pushed to the remote repository, you submit a pull request in order to get your code integrated with the main branch. If a merge conflict is encountered, you will have to resolve it locally, using for example the Visual Studio Team Explorer or by simply opening the .json files in a text editor to resolve the conflicts (git inserts conflict markers to indicate which part of the code has conflicts).
+7. Once all conflicts are resolved, there may be a process of code review, automated build/test execution based on branch policies, etc. to get the pull request completed. This, however, depends on your branching strategy and overall setup.
+
+We present more details about how to configure git branch policies, set up automated build and deployment pipelines, etc. using Azure DevOps in the following articles. Similar techniques can be used in other automated build and git hosting environments, such as TeamCity, GitHub, etc.
+
+# Next steps
+
+- @powerbi-cicd
+- @as-cicd
+- @optimizing-workflow-workspace-mode
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-personalizing-te3.md b/onboarding/ja-jp/ja-personalizing-te3.md
new file mode 100644
index 0000000..f284504
--- /dev/null
+++ b/onboarding/ja-jp/ja-personalizing-te3.md
@@ -0,0 +1,252 @@
+---
+uid: personalizing-te3
+title: Personalizing and configuring Tabular Editor 3 to suit your needs
+author: Daniel Otykier
+updated: 2021-09-28
+---
+
+# Personalizing and configuring Tabular Editor 3 to suit your needs
+
+Tabular Editor 3 provides a wide range of configuration options, that allow you to tweak the tool to your specific needs and preferred workflow. In this article, we will guide you through the settings that are most commonly adjusted by individual model developers.
+
+Most of the settings covered in this article are accessed through the **Tools > Preferences** menu option. Throughout the article, we will list individual settings in the following style, for easy reference:
+
+***Name of setting* (default value)** Description of setting.
+
+# General features
+
+The first page you will encounter within the **Preferences** dialog is the **Tabular Editor > Features** page (see screenshot below). Below is a short description of the features on this page, and what they are commonly used for:
+
+
+
+## Power BI
+
+These settings are mostly useful for developers who use Tabular Editor 3 as an [External Tool for Power BI Desktop](https://docs.microsoft.com/en-us/power-bi/transform-model/desktop-external-tools).
+
+##### *Allow unsupported modeling operations* (disabled)
+
+External Tools for Power BI Desktop have some [limitations](xref:desktop-limitations). By default, Tabular Editor 3 will prevent the user from making unsupported changes to the data model. There may be some advanced modeling features which work well, even though they are not supported cf. the previous link. To unlock all Tabular Object Model objects and properties, enable this setting.
+
+##### *Hide auto date/time warnings* (disabled)
+
+When the "Auto date/time" setting in Power BI Desktop is enabled, a number of calculated tables are created automatically. Unfortunately, these tables contain DAX code which trigger a warning message by Tabular Editor 3's built-in DAX analyzer. To hide these warnings, enable this setting.
+
+##### *Line break on first line of DAX* (disabled)
+
+In Power BI Desktop it is common to insert a line break on the first line of a DAX expression, due to the way the formula bar displays the DAX code. If you often switch back and forth between Tabular Editor and Power BI Desktop, consider enabling this option to have Tabular Editor 3 insert the line break automatically, whenever a DAX expression is edited through the tool.
+
+## Metadata Synchronization
+
+These settings controls the behavior of Tabular Editor 3, when model metadata is loaded from a database on an instance of Analysis Services. The settings specify how Tabular Editor 3 should deal with metadata changes applied to the database from outside the application, such as when another user makes a change to the database, or when you make a change to the model through Power BI Desktop while Tabular Editor 3 is used as an external tool.
+
+##### *Warn when local metadata is out-of-sync with deployed model* (enabled)
+
+When this is checked, Tabular Editor displays a warning message when you attempt to save changes, while another user or process has made a change to the database since the model metadata was loaded into your instance of Tabular Editor.
+
+##### *Track external model changes* (enabled)
+
+This option is only relevant for local instances of Analysis Services (i.e. msmdsrv.exe processes running on the same machine as Tabular Editor). When checked, Tabular Editor starts a trace on Analysis Services and notifies you if external changes are made.
+
+##### *Refresh local Tabular Object Model metadata automatically* (enabled)
+
+When the tracing mechanism as described above is enabled, this option allows Tabular Editor to automatically refresh the model metadata when an external change is detected. This is useful if you often switch back and forth between Power BI Desktop and Tabular Editor 3, as this ensures that changes made in Power BI Desktop are automatically sync'ed to Tabular Editor.
+
+##### *Cleanup orphaned Tabular Editor traces*
+
+Normally, Tabular Editor 3 should automatically stop and remove any AS traces started due to the settings above. However, if the application was shut down prematurely, the traces may never be stopped. By clicking this button, all AS traces started by any instance of Tabular Editor, on the current instance of Analysis Services, will be removed.
+
+> [!NOTE]
+> The cleanup button is only available when Tabular Editor is connected to an instance of Analysis Services.
+
+# TOM Explorer settings
+
+The settings below control various aspects of the TOM Explorer. You can find these settings under **Tabular Editor > TOM Explorer**:
+
+
+
+##### *Show full branch* (disabled)
+
+When filtering the TOM Explorer, by default Tabular Editor 3 shows all items in the hierarchy that matches the filter string, including their parents. If you want to see all child items as well (even though these might not match the filter string), enable this option.
+
+##### *Always show delete warnings* (disabled)
+
+If you prefer Tabular Editor 3 to prompt you to confirm all object deletions, enable this setting. Otherwise, Tabular Editor 3 will only prompt you to confirm multi-object deletions, or deletions of objects that are referenced by other objects.
+
+> [!NOTE]
+> All delete operations in Tabular Editor 3 can be undone by hitting CTRL+Z.
+
+# DAX editor general settings
+
+Tabular Editor 3's DAX editor is highly configurable, and it is easy to get overwhelmed by the many settings available. This section highlights the most common and important settings. Locate the general settings under **Text Editors > DAX Editor > General**:
+
+
+
+## General
+
+The *Line numbers*, *Code folding*, *Visible whitespace* and *Indentation guides* settings can be used to toggle various visual feature of the editor. In the screenshot below, all four options have been enabled:
+
+
+
+##### *Use tabs* (disabled)
+
+When this is checked, a tab character (`\t`) is inserted whenever the TAB button is hit. Otherwise, a number of spaces corresponding to the *Indent width* setting is inserted.
+
+##### *Comment style* (slashes)
+
+DAX supports line comments that use slashes (`//`) or hyphens (`--`). This setting determines which style of comment is used when Tabular Editor 3 generates DAX code, such as when using the DAX script feature.
+
+## DAX Settings
+
+These settings determine certain behavior of the DAX code analyzer. The *Locale* setting is simply a matter of preference. All other settings are relevant only when Tabular Editor 3 cannot determine the version of Analysis Services used, as is the case for example when a Model.bim file is loaded directly. In this case, Tabular Editor tries to guess which version the model will be deployed to, based on the compatibility level specified in the model, but depending on the actual version of the deployment target, there may be various DAX language differences, which Tabular Editor cannot determine. If Tabular Editor reports incorrect semantic/syntax errors, you may need to tweak these settings.
+
+# Auto Formatting
+
+On the **Text Editors > DAX Editor > Auto Formatting** page, you can find a wide range of settings for controlling how your DAX code is formatted.
+
+
+
+##### *Auto format code as you type* (enabled)
+
+This option will automatically apply certain formatting rules whenever certain keystrokes occur. For example, when a parenthesis is closed, this feature will ensure that everything within the parentheses is formatted according to the other settings on this page.
+
+##### *Auto-format function calls* (enabled)
+
+This option specifically controls whether automatic formatting of function calls (that is, spacing between arguments and parentheses), should happen when a parenthesis is closed.
+
+##### *Auto-indent* (enabled)
+
+This option automatically indents function arguments when a line break is inserted within a function call.
+
+##### *Auto-brace* (enabled)
+
+This option automatically inserts the closing brace or quote whenever an opening brace or quote is entered.
+
+##### *Wrap selection* (enabled)
+
+When enabled, this option automatically wraps the current selection with the closing brace, when an opening brace is entered.
+
+## Formatting rules
+
+These settings control how DAX code whitespace is formatted, both when auto-formatting occurs, but also when code is manually formatted (using the **Format DAX** menu options).
+
+##### *Space after functions* (disabled)
+
+# [Enabled](#tab/tab1)
+
+```DAX
+SUM ( 'Sales'[Amount] )
+```
+
+# [Disabled](#tab/tab2)
+
+```DAX
+SUM( 'Sales'[Amount] )
+```
+
+***
+
+##### *Newline after functions* (disabled)
+
+Applies only when a function call needs to be broken across multiple lines.
+
+# [Enabled](#tab/tab3)
+
+```DAX
+SUM
+(
+ 'Sales'[Amount]
+)
+```
+
+# [Disabled](#tab/tab4)
+
+```DAX
+SUM(
+ 'Sales'[Amount]
+)
+```
+
+***
+
+##### *Newline before operator* (enabled)
+
+Applies only when a binary operation needs to be broken across multiple lines.
+
+# [Enabled](#tab/tab5)
+
+```DAX
+[Internet Total Sales]
+ + [Reseller Total Sales]
+```
+
+# [Disabled](#tab/tab6)
+
+```DAX
+[Internet Total Sales] +
+ [Reseller Total Sales]
+```
+
+***
+
+##### *Pad parentheses* (enabled)
+
+# [Enabled](#tab/tab7)
+
+```DAX
+SUM( Sales[Amount] )
+```
+
+# [Disabled](#tab/tab8)
+
+```DAX
+SUM(Sales[Amount])
+```
+
+***
+
+##### *Long format line limit* (120)
+
+The maximal number of characters to keep on a single line before an expression is broken across multiple lines, when using the **Format DAX (long lines)** option.
+
+##### *Short format line limit* (60)
+
+The maximal number of characters to keep on a single line before an expression is broken across multiple lines, when using the **Format DAX (short lines)** option.
+
+> [!NOTE]
+> Most settings above are only in effect when using the (default) built-in DAX formatter.
+
+## Casings and quotes
+
+In addition to formatting the DAX code whitespace, Tabular Editor 3 can also fix object references and function/keyword casings.
+
+##### *Fix measure/column qualifiers* (enabled)
+
+When this is checked, table prefixes are automatically removed from measure references, and automatically inserted on column references.
+
+##### *Preferred keyword casing* (default = UPPER)
+
+This setting allows you to change the casing used for keywords, such as `ORDER BY`, `VAR`, `EVALUATE`, etc. This also applies when a keyword is inserted through the auto-complete feature.
+
+##### *Preferred function casing* (default = UPPER)
+
+This setting allows oyu to change the casing used for functions, such as `CALCULATE(...)`, `SUM(...)`, etc. This also applies when a function is inserted through the auto-complete feature.
+
+##### *Fix keyword/function casing* (enabled)
+
+When this is checked, casing of keywords and functions is automatically corrected whenever code is auto-formatted or manually formatted.
+
+##### *Fix object reference casing* (enabled)
+
+DAX is a case-insensitive language. When this is enabled, references to tables, columns and measures are automatically corrected such that the casing matches the physical name of the referenced objects. This fixup happens whenever code is auto-formatted or manually formatted.
+
+##### *Always quote tables* (disabled)
+
+Referencing certain table names do not require surrounding single quotes in DAX. However, if you prefer table references to always be quoted, regardless of the table name, you can check this option.
+
+##### *Always prefix extension columns* (disabled)
+
+Extension columns can be defined without a table name. When this is checked, the DAX editor will always add the table prefix to an extension column, even if the table name is blank. In that case, the column reference will look like `''[Extension Column]`.
+
+# Next steps
+
+- @boosting-productivity-te3
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-powerbi-cicd.md b/onboarding/ja-jp/ja-powerbi-cicd.md
new file mode 100644
index 0000000..04266df
--- /dev/null
+++ b/onboarding/ja-jp/ja-powerbi-cicd.md
@@ -0,0 +1,10 @@
+---
+uid: powerbi-cicd
+title: Power BI CI/CD with Azure DevOps and Tabular Editor
+author: Daniel Otykier
+updated: 2021-10-04
+---
+
+# Power BI CI/CD with Azure DevOps and Tabular Editor
+
+(WIP)
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-refresh-preview-query.md b/onboarding/ja-jp/ja-refresh-preview-query.md
new file mode 100644
index 0000000..cfc0ed0
--- /dev/null
+++ b/onboarding/ja-jp/ja-refresh-preview-query.md
@@ -0,0 +1,162 @@
+---
+uid: refresh-preview-query
+title: Refreshing, previewing and querying data
+author: Daniel Otykier
+updated: 2021-09-30
+applies_to:
+ editions:
+ - edition: Desktop
+ partial: Refreshing tables through external tools is currently not supported by Power BI Desktop, even though Tabular Editor 3 Desktop Edition allows this operation. Querying data is fully supported.
+ - edition: Business
+ - edition: Enterprise
+---
+# Refreshing, previewing and querying data
+
+When Tabular Editor 3 is connected to an instance of Analysis Services, a number of additional **connected features** are available, allowing you to use Tabular Editor 3 as a client tool for Analysis Services.
+
+> [!NOTE]
+> The phrase "connected to an instance of Analysis Services" means any one of the following:
+>
+> - Loading a model in [**workspace mode**](xref:workspace-mode)
+> - Loading a model directly from SQL Server Analysis Services, Azure Analysis Services or the Power BI XMLA endpoint
+> - Using Tabular Editor 3 as an external tool for Power BI Desktop
+
+In summary, these connected features are:
+
+- Data refresh operations
+- Table data previewing
+- PivotGrids
+- DAX Querying
+- VertiPaq Analyzer
+
+# Refreshing data
+
+Tabular Editor does not automatically trigger refresh operations in Analysis Services when changes are made to the data model. This is by design, to ensure that saving metadata changes to Analysis Services does not take too long. Potentially, a refresh operation can take a long time to complete, during which no additional metadata may be updated on the server. Of course, the drawback of this, is that you can make changes using Tabular Editor, which causes the model to enter a state where it is only partly queryable or not queryable at all. Depending on what type of data model change was made, different levels of refresh may be needed.
+
+In general, the following changes require a full refresh, before the mentioned object can be queried (that is, a data refresh followed by a calculate refresh):
+
+- Adding a new table to the model
+- Adding a new column to a table
+
+In general, the following changes require a calculate refresh:
+
+- Changing the DAX expression of a calculated table or calculated column
+- Adding or modifying a relationship
+- Adding, renaming or removing a calculation item from a calculation group
+
+Notably, adding, modifying or removing measures from a model does not require any type of refresh (unless the measure is referenced by a calculated column, in which case the table in which that column resides has to be recalculated).
+
+To initiate a refresh using Tabular Editor, simply right click on the Table or Partition you wish to refresh, navigate to **Refresh table** or **Refresh partition**, and then choose the type of refresh you want to perform.
+
+
+
+You may also initiate a refresh at the model level through the **Model > Refresh model** menu. Once the refresh operation starts, you will see the text "Data refresh started... View refresh queue". Click on the link or locate the **Data refresh** view through the **View > Data refresh** menu option. This will display a list of all refresh operations (both present and current), displaying the status message returned from Analysis Services including progress counters and duration, and allowing you to cancel an unintended refresh.
+
+
+
+While a refresh is in progress you can continue work on your data model, querying and previewing data or queueing new data refresh operations according to this article. However, you will not be able to save model changes to Analysis Services until the all data refresh operations complete.
+
+> [!NOTE]
+> Currently, [Power BI Desktop does not support refresh operations triggered from external tools](https://docs.microsoft.com/en-us/power-bi/transform-model/desktop-external-tools#data-modeling-operations). For this reason, Tabular Editor 3 hides these options when connected to an instance of Power BI Desktop. You can override this behavior by enabling **Tools > Preferences > Allow unsupported modeling operations**.
+
+## Supported refresh operations
+
+Tabular Editor 3 supports refresh operations on different object types. The supported refresh types are shown below:
+
+- **Model** (Automatic, calculate, full)
+- **(Imported) Table** (Automatic, calculate, data only, full)
+- **Partition** (Full)
+- **Calculated Table** (Calculate)
+- **Calculation Group** (Calculate)
+
+See [Refresh Types](https://docs.microsoft.com/en-us/analysis-services/tmsl/refresh-command-tmsl?view=asallproducts-allversions#request) for more information about the types of refresh operations supported by Analysis Services / Power BI.
+
+# Previewing table data
+
+At certain points during DAX authoring and data model development, you may need to inspect the contents of your tables on a row-by-row basis. Of course, you could write a DAX query to achieve this, but Tabular Editor 3 makes that even easier by allowing you to preview table data directly. To do this, right-click on a table and choose the **Preview data** option.
+
+
+
+You can open multiple such table previews and arrange them anyway you like in the user interface. In addition, you can sort or filter individual columns. There is no practical limit to the number of rows that can be previewed. Tabular Editor simply executes a [`TOPNSKIP`](https://dax.guide/topnskip) DAX query against the model, to return just a small number of records suitable to fill the current view.
+
+If one or more calculated columns are in an invalid state, those columns contain the text *(Calculation needed)*. You can recalculate the table by right-clicking on the column and choosing the **Recalculate table...** option.
+
+
+
+# Pivot Grids
+
+After adding or editing DAX measures in a model, it is common for model developers to test these measures. Traditionally, this was typically done using client tools such as Excel or Power BI. With Tabular Editor 3, you can now use **Pivot Grids** which behave much like the famous PivotTables of Excel. The Pivot Grid lets you quickly create summarized views of the data in your model, allowing you test the behavior of your DAX measures when filtering and slicing by various columns and hierarchies.
+
+To create a new Pivot Grid, use the **File > New > Pivot Grid** option. From here, you can either drag measures, columns and hierarchies from the TOM Explorer into the grid, or you can use the **Pivot Grid > Show fields** menu option to display a popup list of all fields that can be dragged into the Pivot Grid (see screenshot below).
+
+
+
+As fields are dragged into the Pivot Grid, Tabular Editor generates MDX queries that are sent to Analysis Services, to display the resulting data. In this regard, the behavior is very similar to Pivot Tables in Excel. You can rearrange fields in the Pivot Grid by dragging and dropping, and there are various right-click menu options available for customizing how the data is displayed.
+
+
+
+The Pivot Grid is automatically refreshed when a change is made to the model or a refresh operation finishes. You can toggle this auto-refresh capability within the **Pivot Grid** menu.
+
+# DAX Queries
+
+A more direct way to query the data in your model, is to write a DAX query. Use the **File > New > DAX Query** menu option to create a new DAX query document. You can have multiple DAX query documents open at the same time.
+
+DAX queries can be saved and loaded to and from standalone files using the `.dax` or `.msdax` file extension. See @supported-files for more information.
+
+Type your DAX `EVALUATE` query into the editor and hit **Query > Execute** (F5) to send the query to Analysis Services and see the result. By default, Tabular Editor 3 limits the number of rows returned from Analysis Services to 1000, but this can be changed under **Tools > Preferences > Data Browsing > DAX Query**. If a query exceeds this limit, Tabular Editor 3 displays a shortcut that lets you retrieve all records (see screenshot below).
+
+
+
+> [!WARNING]
+> Displaying a large number of records in the query result window could take a while and drastically increase the memory consumed by Tabular Editor 3.
+
+Tabular Editor 3 uses the same DAX code editor for query editing as for defining DAX expressions on objects. As such, all the features regarding code-completion, auto-formatting, etc. are available. See @dax-editor for more information. In addition, since a DAX query has a slightly different syntax than object expressions, the DAX query editor provides a few more options for common tasks.
+
+For example, if you right-click on a measure reference, there is an option to **Define measure** as seen on the screenshot below. This option will add a `DEFINE MEASURE` statement at the top of your DAX query, allowing you to easily modify the DAX expression of that measure within the scope of the query.
+
+
+
+In addition, a DAX query can contain multiple `EVALUATE` statements. When that is the case, Tabular Editor 3 displays the result from each such statement on a separate, numbered tab. If you only want to execute a single `EVALUATE` statement, even though your document contains multiple, you can place the cursor somewhere within the statement you want to execute, and then use the **Query > Execute selection** (SHIFT+F5) option.
+
+A DAX query in Tabular Editor 3 is automatically refreshed when a change is made to the model or a refresh operation finishes. You can toggle this auto-refresh capability within the **Query** menu.
+
+# Impersonation
+
+When querying the data in the model, it is sometimes useful to be able to impersonate a specific user or a combination of roles, to see what the behavior of the model from an end user perspective would be. Tabular Editor 3 allows you to impersonate a specific user or one or more roles, by clicking on the **Impersonate...** button. This applies to [Table previews](#previewing-table-data), [Pivot Grids](#pivot-grids) and [DAX queries](#dax-queries).
+
+> [!NOTE]
+> To impersonate a user, Tabular Editor adds the [`EffectiveUserName` property](https://docs.microsoft.com/en-us/analysis-services/instances/connection-string-properties-analysis-services?view=asallproducts-allversions#effectiveusername) to the connection string, when connecting to Analysis Services. To impersonate a role, Tabular Editor adds the [`Roles` property](https://docs.microsoft.com/en-us/analysis-services/instances/connection-string-properties-analysis-services?view=asallproducts-allversions#roles) to the connection string. This only applies to the data view (i.e. the DAX query, the Pivot Grid or the Table Preview) where the impersonation is specified.
+
+When clicking on the **Impersonation..** button (which can also be found through the **Query**, **Pivot Grid** or **Table Preview** menu, depending on which type of data view is active), a popup allows you to specify either a user, or select one or more roles.
+
+
+
+Once the impersonation is enabled, the **Impersonation..** button is checked, and the impersonation will be applied to the current data view. By clicking on the small arrow next to the **Impersonation..** button, you can view and quickly switch between the 10 most recent impersonations used.
+
+
+
+When auto-refresh is enabled on a data view, changing the impersonation will immediately refresh the view.
+
+# VertiPaq Analyzer
+
+Tabular Editor 3 includes a version of the open-source [VertiPaq Analyzer](https://www.sqlbi.com/tools/vertipaq-analyzer/) tool, created by [SQLBI](https://sqlbi.com). VertiPaq Analyzer is useful to analyze VertiPaq storage structures for your Power BI or Tabular data model.
+
+With Tabular Editor 3, you can collect VertiPaq Analyzer statistics while you are connected to any instance of Analysis Services. You can also export the statistics as a [.vpax file](https://www.youtube.com/watch?v=zRa9y01Ub30), or import statistics from a .vpax file.
+
+To collect statistics, simply hit the **Collect stats** button in the **VertiPaq Analyzer** view.
+
+
+
+Once statistics are collected, VertiPaq Analyzer displays a summary of the model size, number of tables, etc. You can find more detailed statistics on the **Tables**, **Columns**, **Relationships** and **Partitions** tabs.
+
+Additionally, whenever statistics have been loaded, Tabular Editor 3 will display cardinality and size information as a tooltip when hovering the mouse cursor over objects in the TOM Explorer:
+
+
+
+...or when hovering the mouse cursor over object references in DAX expressions:
+
+
+
+# Next steps
+
+- @creating-and-testing-dax
\ No newline at end of file
diff --git a/onboarding/ja-jp/ja-toc.md b/onboarding/ja-jp/ja-toc.md
new file mode 100644
index 0000000..8f45f47
--- /dev/null
+++ b/onboarding/ja-jp/ja-toc.md
@@ -0,0 +1,18 @@
+# [Welcome](index.md)
+# @general-introduction
+## @installation-activation-basic
+## @migrate-from-vs
+## @migrate-from-desktop
+## @migrate-from-te2
+# @parallel-development
+## @optimizing-workflow-workspace-mode
+## @powerbi-cicd
+## @as-cicd
+# @boosting-productivity-te3
+## @importing-tables-data-modeling
+## @refresh-preview-query
+## @creating-and-testing-dax
+## @dax-script-introduction
+## @bpa
+## @cs-scripts-and-macros
+## @personalizing-te3
\ No newline at end of file
diff --git a/te2/Ja-jp/ja-Advanced-Filtering-of-the-Explorer-Tree.md b/te2/Ja-jp/ja-Advanced-Filtering-of-the-Explorer-Tree.md
new file mode 100644
index 0000000..98f2756
--- /dev/null
+++ b/te2/Ja-jp/ja-Advanced-Filtering-of-the-Explorer-Tree.md
@@ -0,0 +1,87 @@
+# 高度なオブジェクトフィルタリング
+
+この記事では、複雑なモデルを操作する際に非常に便利な機能である、Tabular Editorの「フィルター」テキストボックスの使用方法について説明します。
+
+## Filtering Mode
+
+[2.7.4](https://github.com/otykier/TabularEditor/releases/tag/2.7.4)より、Tabular Editorでは、階層内のオブジェクトにどのようにフィルターを適用するか、また検索結果をどのように表示するかを設定できるようになりました。これは、Filterボタンの隣にある3つの右端のツールバーボタンを使ってコントロールします。
+
+
+
+*  **Hierarchical by parent**: 検索は、_parent_オブジェクト、つまりテーブルとディスプレイフォルダ（これらが有効な場合）に適用されます。親アイテムが検索条件に一致すると、すべての子アイテムが表示されます。
+*  **Hierarchical by children**: この検索は、_child_オブジェクト（メジャー、カラム、階層など）に適用されます。親オブジェクトは、検索条件に一致する子オブジェクトを少なくとも1つ持っている場合にのみ表示されます。
+*  **Flat**: 検索はすべてのオブジェクトに適用され、結果はフラットなリストで表示されます。子項目を含むオブジェクトは、引き続き階層的に表示されます。
+
+## 簡易検索
+
+[Filter]テキストボックスに何かを入力して[Enter]を押すと、オブジェクト名の中で大文字と小文字を区別しないシンプルな検索が行われます。例えば、Filterテキストボックスに「sales」と入力し、「By Parent」フィルタリングモードを使用すると、次のような結果が得られます。
+
+
+
+いずれかのテーブルを展開すると、そのテーブルのすべてのメジャー、列、階層、およびパーティションが表示されます。フィルタリングモードを「By Child」に変更すると、結果は次のようになります。
+
+
+
+[Employee」テーブルは、「sales」という単語を含むいくつかの子項目（この場合は列）を持っているため、リストに表示されていることに注目してください。
+
+## ワイルドカード検索
+
+テキストボックスに文字列を入力する際、ワイルドカードとして `?` を使用すると任意の1文字を、 `*` を使用すると任意の連続した文字（0文字以上）を表すことができます。しかし、`sales*`と入力すると、名前が "sales" という単語で始まるオブジェクトのみが表示されます（繰り返しますが、これは大文字と小文字を区別しません）。
+
+Searching for `sales*` by parent:
+
+
+
+Searching for `sales*` by child:
+
+
+
+フラット検索で `sales*` を検索（情報欄の切り替え [Ctrl]+[F1] で各オブジェクトの詳細情報が表示されます）。
+
+
+
+ワイルドカードは文字列のどこにでも入れることができ、必要な数だけ入れることができます。これでもまだ複雑でないなら、続きを読んでください...
+
+## 動的なLINQ検索
+
+[Dynamic LINQ](https://github.com/kahanu/System.Linq.Dynamic/wiki/Dynamic-Expressions) を使ってオブジェクトを検索することもできます。これは [Best Practice Analyzer rules](/Best-Practice-Analyzer) を作成するときに行うのと同じことです。フィルタボックスでDynamic LINQモードを有効にするには、検索文字列の前に `:` (コロン) を置くだけです。たとえば、名前が "Key" で終わるすべてのオブジェクトを表示するには、次のように記述します (大文字と小文字を区別します)。
+
+```
+:Name.EndsWith("Key")
+```
+
+...そして[Enter]キーを押します。フラット」フィルタリングモードでは、以下のような結果になります。
+
+
+
+Dynamic LINQで大文字小文字を区別しない検索を行うには、以下のような方法で入力文字列を変換できます。
+
+```
+:Name.ToUpper().EndsWith("KEY")
+```
+
+下のように、[StringComparison](https://docs.microsoft.com/en-us/dotnet/api/system.string.endswith?view=netframework-4.7.2#System_String_EndsWith_System_String_System_StringComparison_) という引数を与えることもできます。
+
+```
+:Name.EndsWith("Key", StringComparison.InvariantCultureIgnoreCase)
+```
+
+検索対象はオブジェクトの名前に限定されるわけではありません。動的LINQ検索文字列は、オブジェクトのあらゆるプロパティ（およびサブプロパティ）を評価するために、好きなだけ複雑にできます。たとえば、"TODO "という単語を含む式を持つすべてのオブジェクトを検索したい場合、次のような検索フィルターを使用することになります。
+
+```
+:Expression.ToUpper().Contains("TODO")
+```
+
+別の例として、以下では、他の何からも参照されていないモデル内のすべての非表示メジャーが表示されます。
+
+```
+:ObjectType="Measure" and (IsHidden or Table.IsHidden) and ReferencedBy.Count=0
+````
+
+また、正規表現を使うこともできます。以下は、名前に「Number」または「Amount」という単語が含まれるすべてのカラムを検索します。
+
+```
+:ObjectType="Column" and RegEx.IsMatch(Name,"(Number)|(Amount)")
+```
+
+表示オプション（ツリーの真上にあるツールバーボタン）は、"By Parent" と "By Child" フィルタリングモードを使用した場合の結果に影響を与える可能性があることに注意してください。たとえば、上記のLINQフィルターは列のみを返しますが、表示オプションが現在、列を表示しないように設定されている場合、何も表示されません。
diff --git a/te2/Ja-jp/ja-Advanced-Scripting-and-Dynamic-LINQ-quiz.md b/te2/Ja-jp/ja-Advanced-Scripting-and-Dynamic-LINQ-quiz.md
new file mode 100644
index 0000000..ca10281
--- /dev/null
+++ b/te2/Ja-jp/ja-Advanced-Scripting-and-Dynamic-LINQ-quiz.md
@@ -0,0 +1,100 @@
+# あなたはTabular Editorのプロですか？
+
+Tabular EditorのAdvanced ScriptingとDynamic LINQフィルター式についての知識をテストしてください。ここにある質問はすべて、たった1行のコードで答えられるかもしれません。
+
+これらの機能をはじめて使う場合は、ここで紹介するソリューション（C#版とDynamic LINQ版の両方）に、これらの機能がどのように動作するかについて多くの有用な情報が掲載されていますので、ぜひチェックしてみてください。
+
+***
+
+#### Question #1) メジャーの総数
+
+* モデルのメジャー数はどのように求めますか？
+
+C# スクリプト ソリューション
+
+この設定を有効にすると、デプロイメントウィザードを使用したとき、または（ワークスペースの）データベース接続中に「保存」ボタンをクリックしたときに、既存のモデルのメタデータの圧縮（zip）バージョンがこの場所に保存されます。
+
+## 式の修正と式の依存関係
+
+Tabular Editorは、モデル内のすべてのメジャー、計算カラム、および計算テーブルのDAX式を継続的に解析し、これらのオブジェクトの依存関係ツリーを構築します。この依存関係ツリーは、"File" > "Preferences" で有効にすることができるFormula Fix-up機能に使用されます。式で参照されていたオブジェクトの名前が変更されると、Formula Fix-upによってメジャー、計算カラム、または計算テーブルのDAX式が自動的に更新されます。
+
+依存関係ツリーを可視化するには、エクスプローラツリーでオブジェクトを右クリックし、"依存関係を表示... "を選択します。
+
+
+
+## インポート/エクスポート翻訳
+
+エクスプローラツリーで1つまたは複数のカルチャーを選択し、右クリックして「Export Translations...」を選択すると後でTabular EditorまたはVisual Studioでインポート可能な.jsonファイルが生成されます。Import Translations...」を選択すると、対応する.jsonファイルがインポートされます。既存の翻訳を上書きするかどうかを選択できます。上書きしない場合、.jsonファイルで定義された翻訳は、指定されたカルチャーの翻訳をまだ持っていないオブジェクトにのみ適用されます。
+
+## フォルダーシリアル化
+
+この機能により、TFS、SubVersion、Gitなどのファイルベースのソース管理環境で、SSAS Tabular Modelsをより簡単に統合できます。File" > "Save to Folder... "を選択すると、Tabular EditorはModel.bimファイルを分解し、その内容をModel.bim内のJSONの構造に似たフォルダー構造で個別のファイルとして保存します。その後モデルを保存する際、変更されたメタデータを持つファイルのみが扱われます。つまり、ほとんどのバージョン管理システムはモデルに対して行われた変更を簡単に検出でき、単一のModel.bimファイルを扱う場合よりもソースのマージやコンフリクト処理がずっと簡単になるのです。
+
+
+
+デフォルトでは、オブジェクトはもっとも低いオブジェクト・レベルまでシリアライズされます（つまり、メジャー、カラム、および階層は個別の .jsonファイルとして保存されます）。
+
+さらに、Tabular Editorの[コマンドライン構文](xref:command-line-options)は、このフォルダー構造からモデルをロードしてデータベースに直接デプロイすることをサポートしており、継続的インテグレーションワークフローのためのビルドを簡単に自動化できるようになっています。
+
+メタデータが個々のファイルに保存される粒度をカスタマイズしたい場合は、「ファイル」→「環境設定」で「フォルダーに保存」タブをクリックします。ここでは、JSONシリアライズする際TOMに渡されるいくつかのシリアライズ・オプションを切り替えることができる。さらに、個々のファイルが生成されるオブジェクトの種類をチェックしたり外したりすることもできます。バージョン管理のシナリオでは、1つのテーブルに関連するすべてを1つのファイルに保存したい場合がありますが、他のシナリオでは、カラムやメジャーに個別のファイルが必要な場合となります。
+
+これらの設定は、「フォルダーに保存」機能をはじめて使用したときに、モデル上のアノテーションに保存され、モデルを読み込んでから「保存」ボタンをクリックしたときに設定が再利用されます。新しい設定を適用したい場合は、再度「ファイル > フォルダーに保存...」を使用してください。
+
+
+
+## ユーザー設定ファイル
+
+Tabular Editorを実行すると、いくつかの追加ファイルがディスクの様々な場所に書き込まれます。以下は、これらのファイルの説明とその内容です。
+
+### In %ProgramData%\TabularEditor
+
+- **BPARules.json** すべてのユーザーが利用できるベストプラクティス・アナライザーのルール。
+- **TOMWrapper.dll** このファイルはTabular Editor内でスクリプトを実行する際に使用されます。また、あなたの.NETプロジェクトで.dllを参照し、ラッパーコードを利用できます。Tabular Editorをアップグレードした後、高度なスクリプトの実行に問題がある場合、このファイルを削除してTabular Editorを再起動してください。
+
+- **Preferences.json** このファイルには、"ファイル">"環境設定 "ダイアログで設定したすべての環境設定が保存されます。
+
+### In %AppData%\Local\TabularEditor
+
+- **BPARules.json** 現在のユーザーのみが利用できるベストプラクティス・アナライザーのルール。
+- **CustomActions.json** エクスプローラツリーの右クリックメニューやツールメニューから呼び出すことができる、カスタムスクリプトアクションです。これらのアクションは、「アドバンスト・スクリプト・エディター」タブで作成できます。
+
+- **RecentFiles.json** 最近開いた.bimファイルのリストを保存する。このリストの直近の10項目は、「ファイル」→「最近使ったファイル」メニューに表示されます。
+
+- **RecentServers.json** 最近開いた.bimファイルのリストを保存する。このリストの直近の10項目は、「ファイル」→「最近使ったファイル」メニューに表示されます。
diff --git a/te2/Ja-jp/ja-Best-Practice-Analyzer-Improvements.md b/te2/Ja-jp/ja-Best-Practice-Analyzer-Improvements.md
new file mode 100644
index 0000000..0ca9fb5
--- /dev/null
+++ b/te2/Ja-jp/ja-Best-Practice-Analyzer-Improvements.md
@@ -0,0 +1,75 @@
+# ベストプラクティス・アナライザーの改善
+
+[Tabular Editor 2.8.1](https://github.com/otykier/TabularEditor/releases/tag/2.8.1)では、ベストプラクティスアナライザーが大きく見直されました。
+
+最初に気づくのは、Tabular Editorがベストプラクティスの問題数をメインUI内で直接レポートするようになったことです。
+
+
+
+モデルに変更が加えられると、Best Practice Analyzerはバックグラウンドでモデルの問題点をスキャンします。この機能は、[ファイル] > [環境設定]で無効にすることができます。
+
+リンクをクリック（またはF10キーを押す）すると、新しく改良されたベストプラクティス・アナライザーのUIが表示されます。
+
+
+
+以前のバージョンでベストプラクティス・アナライザーを使用されていた方は、まずUIが完全に再設計され、画面上の占有面積が小さくなっていることにお気づきでしょう。これにより、デスクトップの片側にウィンドウをドッキングさせ、もう片側にはメインウィンドウを表示させ、両方を同時に操作できます。
+
+ベストプラクティス・アナライザー・ウィンドウは、モデル上のすべての**有効なルール**と、各ルールに違反しているオブジェクトを継続的にリストアップします。リスト内の任意の場所を右クリックするか、ウィンドウ上部のツールバーボタンを使用することで、以下のアクションを実行できます。
+
+* **Manage rules...**: 後述する「ルール管理」UIが表示されます。このUIは、メインUIの「ツール > BPAルールの管理...」メニューからもアクセス可能です。
+
+* **Go to object...**: このオプションを選択するか、リスト内のオブジェクトをダブルクリックすると、メインUIで同じオブジェクトに移動します。
+
+* **Ignore item/items**: リスト内の1つまたは複数のオブジェクトを選択し、このオプションを選択すると、選択したオブジェクトに、ベストプラクティス・アナライザーが今後そのオブジェクトを無視すべきことを示す注釈が適用されます。間違ってオブジェクトを無視した場合、画面上部の「無視を表示」ボタンをトグルしてください。これにより、以前に無視したオブジェクトの無視を解除できます。
+
+* **Ignore rule**: リスト内で1つ以上のルールを選択した場合、このオプションは、選択したルールを常に無視することを示す注釈をモデル・レベルに追加します。繰り返しになりますが、「無視を表示」ボタンをトグルすることで、ルールの無視を解除することもできます。
+
+* **Generate fix script**: 修正が簡単なルール（オブジェクトに1つのプロパティを設定するだけで問題が解決することを意味します）には、このオプションが有効になっています。クリックすると、C#スクリプトがクリップボードにコピーされます。このスクリプトをTabular Editorの[Advanced Scripting](/Advanced-Scripting) エリアに貼り付けて、実行する前に確認して、修正を適用できます。
+
+* **Apply fix**: このオプションは、簡単に修正できるルール以外でも利用できます。スクリプトをクリップボードにコピーしなくとも、即座に実行されます。
+
+## ベストプラクティスルールの管理
+
+モデルに適用するルールを追加、削除、修正する必要がある場合、そのための新しいUIも用意されています。ベストプラクティス・アナライザーのウィンドウの左上のボタンをクリックするか、メインウィンドウの「ツール > BPAルールの管理」メニューで表示できます。
+
+
+
+このUIには2つのリストがあります。上のリストは、現在ロードされているルールの**コレクション**を表します。このリストでコレクションを選択すると、そのコレクションで定義されているすべてのルールが下のリストに表示されます。デフォルトでは、3つのルール・コレクションが表示されます。
+
+* **Rules within the current model**: その名前が示すように、これは現在のモデル内で定義されたルールのコレクションです。ルールの定義は、モデルオブジェクトのアノテーションとして保存されます。
+
+* **Rules for the local user**: これらのルールは `%AppData%..\LocalTabularEditorBPARules.json` ファイルに保存されています。これらのルールは、現在ログインしているWindowsユーザーがTabular Editorでロードするすべてのモデルに適用されます。
+
+* **Rules on the local machine**: これらのルールは `%ProgramData%TabularEditor FilterBPARules.json` に格納されます。これらのルールは、現在のマシンで Tabular Editor にロードされるすべてのモデルに適用されます。
+
+同じルール（IDによる）が複数のコレクションにある場合、優先順位は上から下へ、つまり、モデル内で定義されたルールは、ローカルマシンで定義された同じIDのルールよりも優先されます。これにより、例えば、モデル特有の慣習を考慮に入れて、既存のルールを上書きできます。
+
+リストの上部には、**(Effective rules)**という特別なコレクションが表示されます。このコレクションを選択すると、現在ロードされているモデルに実際に適用されるルールのリストが表示され、前述のように、同一のIDを持つルールの優先順位が尊重されます。下のリストには、ルールがどのコレクションに属しているかが表示されます。また、より高い優先順位のコレクションに同じIDのルールが存在する場合、そのルールの名前が削除されることに気づくでしょう。
+
+
+
+### コレクションを追加する
+
+Tabular Editor 2.8.1の新機能は、他のソースからのルールをモデルに含めることができるようになったことです。例えば、ネットワーク共有にあるルールファイルがある場合、そのファイルを現在のモデルのルールコレクションとして含めることができるようになりました。ファイルの場所への書き込み権限があれば、そのファイルからルールの追加、変更、削除を行うことも可能です。この方法で追加されたルール・コレクションは、モデル内で定義されたルールよりも優先されます。このようなコレクションを複数追加した場合、それらを上下に移動して、相互の優先順位を制御できます。
+
+「Add...」ボタンをクリックして、新しいルールコレクションをモデルに追加します。これには、以下のオプションがあります。
+
+
+
+* **Create new Rule File**: これにより、指定された場所に新しい空の.jsonファイルが作成され、その後、ルールを追加することができます。ファイルを選択するとき、相対的なファイルパスを使用するオプションがあることに注意してください。これは、現在のモデルと同じコードリポジトリにルールファイルを格納したい場合に便利です。ただし、相対的なルール・ファイルの参照は、モデルがディスクからロードされたときにのみ機能することに注意してください (Analysis Services のインスタンスからモデルをロードするときには作業ディレクトリが存在しないため)。
+* **Include local Rule File**: ルールの入った.jsonファイルがすでにあり、それをモデルに含めたい場合、このオプションを使用します。ここでも、相対ファイル・パスを使用するオプションがあり、ファイルがモデル・メタデータの近い場所にある場合、有効です。ファイルがネットワーク共有（または、一般的には、現在ロードされているモデル・メタデータが存在する場所とは異なるドライブ）にある場合、絶対パスを使用してのみ、そのファイルをインクルードできます。
+* **Include Rule File from URL**: このオプションを使用すると、有効なルール定義（json）を返すHTTP/HTTPS URLを指定できます。これは、例えば[BestPracticeRules GitHub site](https://github.com/TabularEditor/BestPracticeRules)の[標準BPAルール](https://raw.githubusercontent.com/TabularEditor/BestPracticeRules/master/BPARules-standard.json)など、オンラインソースからルールを含める場合に便利です。オンラインソースから追加されたルールコレクションは、読み取り専用になることを注意してください。
+
+### コレクション内のルールを変更する
+
+画面下部では、コレクションが保存されている場所への書き込み権限があれば、現在選択されているコレクション内のルールを追加、編集、クローン、削除できます。また、「Move to...」ボタンにより、選択したルールを別のコレクションに移動またはコピーすることができ、複数のルールのコレクションを容易に管理できます。ルール定義を編集するUIは、以前のバージョンのTabular Editorと変わりませんので、その使い方は[旧Best Practice Analyzerの記事](/Best-Practice-Analyzer#rule-expression-samples)を参照してください。
+
+### ルール説明のプレースホルダー
+
+以前のバージョンと比較した小さな改良点として、ベストプラクティスルールの説明で次のプレースホルダー値を使用できるようになりました。これにより、ベストプラクティスUIにツールチップとして表示される説明文をよりカスタマイズできるようになりました。
+
+* `%object%` 現在のオブジェクトに対する完全修飾されたDAXリファレンス（該当する場合）を返します。
+* `%objectname%` は、現在のオブジェクトの名前のみを返します。
+* `%objecttype%` 現在のオブジェクトの型を返します。
+
+
diff --git a/te2/Ja-jp/ja-Best-Practice-Analyzer.md b/te2/Ja-jp/ja-Best-Practice-Analyzer.md
new file mode 100644
index 0000000..5b48930
--- /dev/null
+++ b/te2/Ja-jp/ja-Best-Practice-Analyzer.md
@@ -0,0 +1,147 @@
+# ベストプラクティス・アナライザー
+
+> ベストプラクティス・アナライザーは Tabular Editor v. 2.8.1 で全面的に改良されたため、この記事の情報やスクリーンショットの一部は古くなっています[Best-Practice-Analyzer-Improvements.md](Best-Practice-Analyzer-Improvements.md)。Dynamic LINQ (ルール式) に関する情報は、現在も最新です。
+
+この[素晴らしい提案](https://github.com/TabularEditor/TabularEditor/issues/39)に触発されて、Tabular Editorのまったく新しい機能であるBest Practice Analyzer (BPA)をご紹介できることを誇りに思います。ツールメニューから「Best Practice Analyzer...」をクリックすると、次のウィンドウが開きます（BPAウィンドウを開いたまま、メインウィンドウでモデルの作業を続けることができます）。
+
+
+
+BPAでは、モデルのメタデータにルールを定義し、SSAS Tabularで開発する際に特定の規約やベストプラクティスを推奨できます。
+
+上のリストでルールの1つをクリックすると、下のリストで指定されたルールの条件を満たすすべてのオブジェクトが表示されます。
+
+
+
+リスト内のオブジェクトをダブルクリックすると、Tabular Editorのメインウィンドウにフォーカスが戻り、エクスプローラツリーでそのオブジェクトが選択されます（「Go to object...」）。また、ルールを完全に無視したり（ルールリストのチェックマークを外すことで可能）、特定のオブジェクトのみを無視するように指定することも可能です。無視はModel.bimファイルのメタデータアノテーションに保存されます。
+
+新しいルールを作成するには、Tabular EditorにTabular Modelをロードした状態で、「Add rule...」をクリックするだけです。新しいウィンドウが開き、ルールの名前、説明、条件を指定できます。
+
+
+
+ビジュアルなルールビルダーは、後のリリースで計画されています。今のところ、ルール条件は[Dynamic LINQ式](https://github.com/kahanu/System.Linq.Dynamic/wiki/Dynamic-Expressions)を使用して指定します。この式では、ドロップダウンで指定したオブジェクトのタイプにあるすべてのプロパティにアクセスすることが可能です。条件を満たすすべてのオブジェクトは、ルールが選択されるとBPA UIに表示されます。
+
+デフォルトではこの方法で作成されたルールは、Tabular Editorで「保存」をクリックすると、Modelオブジェクトのメタデータアノテーションに追加され、Model.bimファイルまたは接続されたデータベースに保存されます。ローカルモデル内に保存されたルールを「グローバル」ルールに昇格させることができます。グローバルルールは、%AppData%Local TieTabularEditorフォルダーにある「BPARules.json」というファイルに保存されます。BPARules.jsonを %ProgramData%TabularEditorフォルダーに置くことで、マシン上のすべてのユーザーがルールを利用できるようにすることもできます。
+
+ルールIDは常に一意である必要があることに注意してください。モデルメタデータ内のルールが%AppData%または%ProgramData%フォルダー内のルールと同じIDを持つ場合、優先順位は次のようになります。
+
+- モデル内にローカル保存されたルール
+- AppData%Localフォルダーに保存されたルール
+- ProgramData%フォルダーに格納されたルール
+
+## ルール表現サンプル
+
+このセクションでは、ルールを定義するために使用できる動的LINQ式の例をいくつか紹介します。ルール式エディターに入力された式は、テキストボックスからフォーカスが外れるたびに評価され、構文エラーがあれば画面の上部に表示されます。
+
+
+
+ルール式は、TOM内のオブジェクトのパブリックプロパティにアクセスできます。そのタイプのオブジェクトが存在しないプロパティにアクセスしようとした場合、エラーも表示されます。
+
+
+
+"Column "オブジェクトに "Expression" が存在しませんが、ドロップダウンを "Calculated Columns" に切り替えると、上記のステートメントは問題なく動作します。
+
+
+
+Dynamic LINQは、標準的な算術演算子、論理演算子、比較演算子をすべてサポートしており、". "表記を使用すると、すべてのオブジェクトのサブプロパティとメソッドにアクセスすることが可能です。
+
+```
+String.IsNullOrWhitespace(Expression) and not Name.StartsWith("Dummy")
+```
+
+上記のステートメントを計算列、計算テーブル、またはメジャーに適用すると、オブジェクトの名前が "Dummy" というテキストで始まっていない限り、空のDAX式を持つものにフラグが立てられます。
+
+LINQを使用すると、オブジェクトのコレクションを操作することもできます。以下の式をテーブルに適用すると、10以上のカラムを持ち、ディスプレイフォルダーに整理されていないテーブルを見つけることができます。
+
+```
+Columns.Count(DisplayFolder = "") > 10
+```
+
+LINQメソッドを使用してコレクションを反復処理する場合、LINQメソッドの引数として使用される式は常に、コレクション内の項目で評価されます。実際、DisplayFolderは列に対するプロパティであり、Tableレベルには存在しない。
+
+ここでは、Adventure Worksの表形式モデルでこのルールが実行されている様子を見ることができます。Reseller」テーブルが違反であると表示され、「Reseller Sales」が表示されないことに注目してください（後者のカラムはDisplay Folderで整理されています）。
+
+
+
+LINQメソッド内で親オブジェクトを参照するには、特別な "outerIt "構文を使用する。このルールをテーブルに適用すると、テーブル名で始まらない名前のカラムを含むものを見つけることができる。
+
+```
+Columns.Any(not Name.StartsWith(outerIt.Name))
+```
+
+このルールをColumnsに直接適用する方がおそらく理にかなっており、その場合、次のように記述する必要があります。
+
+```
+not Name.StartsWith(Table.Name)
+```
+
+列挙プロパティと比較するには、列挙された値を文字列として渡せばよい。このルールは、名前が "Key" または "ID" で終わり、かつSummarizeByプロパティが "None" に設定されていないすべての列を検索します。
+
+```
+(Name.EndsWith("Key") or Name.EndsWith("ID")) and SummarizeBy <> "None"
+```
+
+## 未使用のオブジェクトを探す
+
+表形式モデルを構築する場合、高い基数を持つ列を何としても避けることが重要です。典型的な原因は、誤ってモデルにインポートされたシステムのタイムスタンプやテクニカルキーなどです。一般的に、モデルには実際に必要なカラムだけが含まれるようにすべきです。ベストプラクティス・アナライザーが、どのカラムが必要ないかを教えてくれるとしたら、それは素晴らしいことだと思いませんか？
+
+次のルールは、そのカラムを報告します。
+
+- ...が非表示になっている（または親テーブルが非表示になっている）。
+- ...どのDAX式からも参照されていない（モデル内のすべてのDAX式（ドリルスルー式、RLSフィルター式を含む）を考慮する
+- リレーションシップがない
+- ...他のカラムの "Sort By "カラムとしては使用されません。
+- ...は、階層のレベルとしては使用されません。
+
+このBPAルールのDynamic LINQ式は次のとおりです。
+
+```
+(IsHidden or Table.IsHidden)
+and ReferencedBy.Count = 0
+and (not UsedInRelationships.Any())
+and (not UsedInSortBy.Any())
+and (not UsedInHierarchies.Any())
+```
+
+同じ手法で、使用されていないメジャーを見つけることができます。メジャーはリレーションシップに参加できないので、もう少し単純になります。そこで、代わりに、指定されたメジャーを参照するダウンストリーム・オブジェクトが表示されているかどうかも考慮することで、少しスパイスを効かせることができます。つまり、メジャー[A]がメジャー[B]から参照され、メジャー[A]と[B]の両方が非表示であり、他のDAX式がこれら2つのメジャーを参照しない場合、開発者にそれらの両方を削除しても安全であることを知らせる必要があります。
+
+```
+(IsHidden or Table.IsHidden)
+and not ReferencedBy.AllMeasures.Any(not IsHidden)
+and not ReferencedBy.AllColumns.Any(not IsHidden)
+and not ReferencedBy.AllTables.Any(not IsHidden)
+and not ReferencedBy.Roles.Any()
+```
+
+## オブジェクトを修正する
+
+場合によっては、ルールの基準を満たすオブジェクトの問題を自動的に修正することが可能です。たとえば、オブジェクトに単純なプロパティを設定するだけでよい場合です。次のルールの背後にあるJSONを詳しく見てみましょう。
+
+```json
+{
+ "ID": "FKCOLUMNS_HIDDEN",
+ "Name": "Hide foreign key columns",
+ "Category": null,
+ "Description": "Columns used on the Many side of a relationship should be hidden.",
+ "Severity": 1,
+ "Scope": "Column",
+ "Expression": "Model.Relationships.Any(FromColumn = outerIt) and not IsHidden and not Table.IsHidden",
+ "FixExpression": "IsHidden = true",
+ "Compatibility": [
+ 1200,
+ 1400
+ ],
+ "IsValid": false
+}
+```
+
+このルールは、リレーションシップで使用されるすべての列 ("Many" / "From" 側）を検索しますが、列またはその親テーブルが非表示になっていない場合です。ユーザは関連 (ディメンジョン）テーブルを使用してデータをフィルタリングする必要があるため、このような列は決して表示しないことをオススメします。したがって、この場合の修正は、列のIsHiddenプロパティをtrueに設定することであり、これはまさに上記の "FixExpression" 文字列が行うことです。これを実際に確認するには、ルールに違反するオブジェクトを右クリックして、「修正スクリプトの生成」を選択します。このスクリプトはAdvanced Script Editorに貼り付けることができ、そこから簡単にコードを確認し、実行できます。
+
+
+
+スクリプトの実行後、モデルへの変更はいつでも取り消し（CTRL+Z）できることを忘れないでください。
+
+この新しいツールに関するフィードバックは大歓迎です。将来的には、Tabular Editorに同梱される普遍的なベストプラクティスのセットを提供し、使い始められるようにする予定です。さらに、ベストプラクティスアナライザーをVisual Studioのプラグインとして利用できるようにする計画も進行中ですので、Tabular Editorを使用していない方でもその恩恵を受けることができます。
+
+## 公式ベストプラクティスルール
+
+Tabular Editorのユーザーに標準的なベストプラクティスのセットを提供するために、新しいGitHub [リポジトリはこちら](https://github.com/TabularEditor/BestPracticeRules)が作成され、コミュニティが貢献できるベストプラクティスルールの公開コレクションとして使用されます。あらゆる種類のTabularモデリングで一般的に実行可能であると判断されたルールは、このリポジトリで定期的に「リリース」に含まれる予定です。後日、Tabular EditorはこれらのルールをGitHubリポジトリから自動的に取得できるようになり、リポジトリからBPARules.jsonファイルを手動でダウンロードする必要がなくなります。
diff --git a/te2/Ja-jp/ja-Command-line-Options.md b/te2/Ja-jp/ja-Command-line-Options.md
new file mode 100644
index 0000000..8df1ec2
--- /dev/null
+++ b/te2/Ja-jp/ja-Command-line-Options.md
@@ -0,0 +1,247 @@
+# Command Line
+
+Tabular Editorは、コマンドラインから実行してさまざまなタスクを実行することができ、自動ビルドやデプロイメントシナリオなどで有用です。
+
+**Note:** TabularEditor.exeはWinFormsアプリケーションなので、Windowsのコマンドプロンプトから直接実行すると、スレッドがすぐにプロンプトに戻ります。このため、コマンドスクリプトなどで問題が発生します。TabularEditor.exeのコマンドラインタスクが完了するのを待つには、常に以下の方法で実行してください。`start /wait TabularEditor ...` を使って実行してください。
+
+Tabular Editorで利用できるコマンドラインオプションを表示するには、次のコマンドを実行します。
+
+**Windows Command line:**
+
+```shell
+start /wait TabularEditor.exe /?
+```
+
+**PowerShell:**
+
+```powershell
+$p = Start-Process -filePath TabularEditor.exe -Wait -NoNewWindow -PassThru -ArgumentList "/?"
+```
+
+Output:
+```
+Tabular Editor 2.16.0 (build 2.16.7781.40242)
+--------------------------------
+Usage:
+
+TABULAREDITOR ( file | server database ) [-S script1 [script2] [...]]
+ [-SC] [-A [rules] | -AX rules] [(-B | -F) output [id]] [-V | -G] [-T resultsfile]
+ [-D [server database [-L user pass] [-O [-C [plch1 value1 [plch2 value2 [...]]]]
+ [-P [-Y]] [-R [-M]]]
+ [-X xmla_script]] [-W] [-E]]
+
+file Full path of the Model.bim file or database.json model folder to load.
+server Server\instance name or connection string from which to load the model
+database Database ID of the model to load
+-S / -SCRIPT Execute the specified script on the model after loading.
+ scriptN Full path of one or more files containing a C# script to execute or an inline
+ script.
+-SC / -SCHEMACHECK Attempts to connect to all Provider Data Sources in order to detect table schema
+ changes. Outputs...
+ ...warnings for mismatched data types and unmapped source columns
+ ...errors for unmapped model columns.
+-A / -ANALYZE Runs Best Practice Analyzer and outputs the result to the console.
+ rules Optional path of file or URL of additional BPA rules to be analyzed. If
+ specified, model is not analyzed against local user/local machine rules,
+ but rules defined within the model are still applied.
+-AX / -ANALYZEX Same as -A / -ANALYZE but excludes rules specified in the model annotations.
+-B / -BIM / -BUILD Saves the model (after optional script execution) as a Model.bim file.
+ output Full path of the Model.bim file to save to.
+ id Optional id/name to assign to the Database object when saving.
+-F / -FOLDER Saves the model (after optional script execution) as a Folder structure.
+ output Full path of the folder to save to. Folder is created if it does not exist.
+ id Optional id/name to assign to the Database object when saving.
+-V / -VSTS Output Visual Studio Team Services logging commands.
+-G / -GITHUB Output GitHub Actions workflow commands.
+-T / -TRX Produces a VSTEST (trx) file with details on the execution.
+ resultsfile File name of the VSTEST XML file.
+-D / -DEPLOY Command-line deployment
+ If no additional parameters are specified, this switch will save model metadata
+ back to the source (file or database).
+ server Name of server to deploy to or connection string to Analysis Services.
+ database ID of the database to deploy (create/overwrite).
+ -L / -LOGIN Disables integrated security when connecting to the server. Specify:
+ user Username (must be a user with admin rights on the server)
+ pass Password
+ -O / -OVERWRITE Allow deploy (overwrite) of an existing database.
+ -C / -CONNECTIONS Deploy (overwrite) existing data sources in the model. After the -C switch, you
+ can (optionally) specify any number of placeholder-value pairs. Doing so, will
+ replace any occurrence of the specified placeholders (plch1, plch2, ...) in the
+ connection strings of every data source in the model, with the specified values
+ (value1, value2, ...).
+ -P / -PARTITIONS Deploy (overwrite) existing table partitions in the model.
+ -Y / -SKIPPOLICY Do not overwrite partitions that have Incremental Refresh Policies defined.
+ -R / -ROLES Deploy roles.
+ -M / -MEMBERS Deploy role members.
+ -X / -XMLA No deployment. Generate XMLA/TMSL script for later deployment instead.
+ xmla_script File name of the new XMLA/TMSL script output.
+ -W / -WARN Outputs information about unprocessed objects as warnings.
+ -E / -ERR Returns a non-zero exit code if Analysis Services returns any error messages after
+ the metadata was deployed / updated.
+```
+
+## Connecting to Azure Analysis Services
+
+コマンドのサーバー名の代わりに、任意の有効なSSAS接続文字列を使用できます。次のコマンドは、Azure Analysis Servicesからモデルをロードし、それをModel.bimファイルとしてローカルに保存します。
+
+**Windows Command Line:**
+
+```shell
+start /wait TabularEditor.exe "Provider=MSOLAP;Data Source=asazure://northeurope.asazure.windows.net/MyAASServer;User ID=xxxx;Password=xxxx;Persist Security Info=True;Impersonation Level=Impersonate" MyModelDB -B "C:\Projects\FromAzure\Model.bim"
+```
+
+**PowerShell:**
+
+```powershell
+$p = Start-Process -filePath TabularEditor.exe -Wait -NoNewWindow -PassThru `
+ -ArgumentList "`"Provider=MSOLAP;Data Source=asazure://northeurope.asazure.windows.net/MyAASServer;User ID=xxxx;Password=xxxx;Persist Security Info=True;Impersonation Level=Impersonate`" MyModelDB -B C:\Projects\FromAzure\Model.bim"
+```
+
+Azure Active Directory 認証ではなく、Service Principal (Application ID and Key) を使って接続したい場合は、以下のような接続文字列を使用します。
+
+```
+Provider=MSOLAP;Data Source=asazure://northeurope.asazure.windows.net/MyAASServer;User ID=app: