j-law-ruby 0.0.3

data/vendor/rust/crates/j-law-core/src/domains/stamp_tax/policy.rs

@@ -0,0 +1,105 @@
+use crate::domains::stamp_tax::context::StampTaxContext;
+use crate::domains::stamp_tax::params::{StampTaxDocumentParams, StampTaxSpecialRule};
+
+/// 印紙税の計算ポリシー。
+pub trait StampTaxPolicy: std::fmt::Debug {
+    /// 適用すべき特例ルールを選択する。
+    ///
+    /// # 法的根拠
+    /// 印紙税法 別表第一 / 租税特別措置法 第91条
+    fn select_special_rule<'a>(
+        &self,
+        ctx: &StampTaxContext,
+        document: &'a StampTaxDocumentParams,
+    ) -> Option<&'a StampTaxSpecialRule>;
+}
+
+/// 国税庁の標準ポリシー。
+#[derive(Debug, Clone, Copy)]
+pub struct StandardNtaPolicy;
+
+impl StampTaxPolicy for StandardNtaPolicy {
+    fn select_special_rule<'a>(
+        &self,
+        ctx: &StampTaxContext,
+        document: &'a StampTaxDocumentParams,
+    ) -> Option<&'a StampTaxSpecialRule> {
+        let date_str = ctx.target_date.to_date_str();
+        document
+            .special_rules
+            .iter()
+            .filter(|rule| rule.matches_date(&date_str))
+            .filter(|rule| {
+                rule.required_flags
+                    .iter()
+                    .all(|flag| ctx.flags.contains(flag))
+            })
+            .filter(|rule| rule.matches_amount(ctx.stated_amount))
+            .min_by_key(|rule| rule.priority)
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use std::collections::HashSet;
+
+    use super::*;
+    use crate::domains::stamp_tax::context::{StampTaxDocumentCode, StampTaxFlag};
+    use crate::domains::stamp_tax::params::{
+        StampTaxAmountUsage, StampTaxBracket, StampTaxChargeMode, StampTaxCitation,
+    };
+    use crate::types::date::LegalDate;
+
+    #[test]
+    fn standard_policy_selects_matching_rule() {
+        let document = StampTaxDocumentParams {
+            code: StampTaxDocumentCode::Article1RealEstateTransfer,
+            label: "第1号".into(),
+            citation: StampTaxCitation {
+                law_name: "印紙税法".into(),
+                article: "別表第一 第1号文書".into(),
+            },
+            charge_mode: StampTaxChargeMode::AmountBrackets,
+            amount_usage: StampTaxAmountUsage::Optional,
+            base_rule_label: "通常".into(),
+            base_tax_amount: None,
+            brackets: vec![],
+            no_amount_tax_amount: Some(200),
+            no_amount_rule_label: Some("記載なし".into()),
+            special_rules: vec![StampTaxSpecialRule {
+                code: "reduced".into(),
+                label: "軽減".into(),
+                priority: 1,
+                effective_from: Some("2014-04-01".into()),
+                effective_until: Some("2027-03-31".into()),
+                required_flags: vec![StampTaxFlag::Article17NonBusinessExempt],
+                tax_amount: Some(0),
+                rule_label: Some("非課税".into()),
+                brackets: vec![StampTaxBracket {
+                    label: "50万円以下".into(),
+                    amount_from: 0,
+                    amount_to_inclusive: Some(500_000),
+                    tax_amount: 0,
+                }],
+                no_amount_tax_amount: None,
+                no_amount_rule_label: None,
+            }],
+        };
+
+        let mut flags = HashSet::new();
+        flags.insert(StampTaxFlag::Article17NonBusinessExempt);
+        let ctx = StampTaxContext {
+            document_code: StampTaxDocumentCode::Article1RealEstateTransfer,
+            stated_amount: Some(100_000),
+            target_date: LegalDate::new(2024, 1, 1),
+            flags,
+            policy: Box::new(StandardNtaPolicy),
+        };
+
+        let rule = StandardNtaPolicy
+            .select_special_rule(&ctx, &document)
+            .unwrap();
+        assert_eq!(rule.code, "reduced");
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/withholding_tax/calculator.rs

@@ -0,0 +1,247 @@
+use std::collections::HashSet;
+
+use crate::domains::withholding_tax::context::{
+    WithholdingTaxCategory, WithholdingTaxContext, WithholdingTaxFlag,
+};
+use crate::domains::withholding_tax::params::{WithholdingTaxMethod, WithholdingTaxParams};
+use crate::domains::withholding_tax::policy::WithholdingTaxPolicy;
+use crate::error::{CalculationError, InputError, JLawError};
+use crate::types::amount::{FinalAmount, IntermediateAmount};
+use crate::types::rate::{MultiplyOrder, Rate};
+
+/// 源泉徴収税額の計算内訳1行。
+#[derive(Debug, Clone)]
+pub struct WithholdingTaxStep {
+    /// 内訳ラベル。
+    pub label: String,
+    /// 当該行の対象金額（円）。
+    pub base_amount: u64,
+    /// 適用税率の分子。
+    pub rate_numer: u64,
+    /// 適用税率の分母。
+    pub rate_denom: u64,
+    /// 当該行の税額（円）。
+    pub result: FinalAmount,
+}
+
+/// 源泉徴収税額の計算結果。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+/// 東日本大震災からの復興のための施策を実施するために必要な財源の確保に関する特別措置法
+#[derive(Debug, Clone)]
+pub struct WithholdingTaxResult {
+    /// 支払総額（円）。
+    pub gross_payment_amount: FinalAmount,
+    /// 源泉徴収税額の計算対象額（円）。
+    pub taxable_payment_amount: FinalAmount,
+    /// 源泉徴収税額（円）。
+    pub tax_amount: FinalAmount,
+    /// 支払総額から源泉徴収税額を控除した後の金額（円）。
+    pub net_payment_amount: FinalAmount,
+    /// 適用されたカテゴリ。
+    pub category: WithholdingTaxCategory,
+    /// カテゴリ表示名。
+    pub category_label: String,
+    /// 応募作品等の入選賞金・謝金の非課税特例を適用したか。
+    pub submission_prize_exempted: bool,
+    /// 適用されたフラグ。
+    pub applied_flags: HashSet<WithholdingTaxFlag>,
+    /// 計算内訳。
+    pub breakdown: Vec<WithholdingTaxStep>,
+}
+
+/// 所得税法第204条第1項に基づく報酬・料金等の源泉徴収税額を計算する。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項（報酬・料金等の源泉徴収）
+/// 国税庁タックスアンサー No.2795 / No.2798 / No.2810
+///
+/// # 計算手順
+/// 1. 請求書等で区分表示された消費税額を支払総額から控除し、課税対象額を求める
+/// 2. カテゴリに対応する計算方式を決定する
+/// 3. 応募作品等の入選賞金・謝金の非課税特例があれば税額を 0 円とする
+/// 4. 100万円以下部分と超過部分にそれぞれ税率を適用し、1円未満切り捨てで合算する
+pub fn calculate_withholding_tax(
+    ctx: &WithholdingTaxContext,
+    params: &WithholdingTaxParams,
+) -> Result<WithholdingTaxResult, JLawError> {
+    ctx.target_date.validate()?;
+
+    let taxable_payment_amount = ctx
+        .payment_amount
+        .checked_sub(ctx.separated_consumption_tax_amount)
+        .ok_or_else(|| InputError::InvalidWithholdingInput {
+            field: "separated_consumption_tax_amount".into(),
+            reason: "消費税額が支払総額を超えています".into(),
+        })?;
+
+    let category_params = params
+        .categories
+        .iter()
+        .find(|category| category.category == ctx.category)
+        .ok_or_else(|| CalculationError::PolicyNotApplicable {
+            reason: format!(
+                "カテゴリ {} に対応する源泉徴収パラメータが見つかりません",
+                ctx.category
+            ),
+        })?;
+
+    let exempted = ctx.policy.should_apply_submission_prize_exemption(
+        ctx.category,
+        taxable_payment_amount,
+        &ctx.flags,
+        category_params.submission_prize_exemption_threshold,
+    );
+
+    if exempted || taxable_payment_amount == 0 {
+        return Ok(WithholdingTaxResult {
+            gross_payment_amount: FinalAmount::new(ctx.payment_amount),
+            taxable_payment_amount: FinalAmount::new(taxable_payment_amount),
+            tax_amount: FinalAmount::new(0),
+            net_payment_amount: FinalAmount::new(ctx.payment_amount),
+            category: ctx.category,
+            category_label: category_params.label.clone(),
+            submission_prize_exempted: exempted,
+            applied_flags: ctx.flags.clone(),
+            breakdown: vec![],
+        });
+    }
+
+    let (tax_amount, breakdown) = match &category_params.method {
+        WithholdingTaxMethod::TwoTier {
+            threshold,
+            base_rate_numer,
+            base_rate_denom,
+            excess_rate_numer,
+            excess_rate_denom,
+        } => calculate_two_tier(
+            taxable_payment_amount,
+            *threshold,
+            *base_rate_numer,
+            *base_rate_denom,
+            *excess_rate_numer,
+            *excess_rate_denom,
+            ctx.policy.as_ref(),
+        )?,
+    };
+
+    let net_payment_amount = ctx
+        .payment_amount
+        .checked_sub(tax_amount.as_yen())
+        .ok_or_else(|| CalculationError::Overflow {
+            step: "net_payment_amount".into(),
+        })?;
+
+    Ok(WithholdingTaxResult {
+        gross_payment_amount: FinalAmount::new(ctx.payment_amount),
+        taxable_payment_amount: FinalAmount::new(taxable_payment_amount),
+        tax_amount,
+        net_payment_amount: FinalAmount::new(net_payment_amount),
+        category: ctx.category,
+        category_label: category_params.label.clone(),
+        submission_prize_exempted: false,
+        applied_flags: ctx.flags.clone(),
+        breakdown,
+    })
+}
+
+fn calculate_two_tier(
+    amount: u64,
+    threshold: u64,
+    base_rate_numer: u64,
+    base_rate_denom: u64,
+    excess_rate_numer: u64,
+    excess_rate_denom: u64,
+    policy: &dyn WithholdingTaxPolicy,
+) -> Result<(FinalAmount, Vec<WithholdingTaxStep>), JLawError> {
+    let base_amount = amount.min(threshold);
+    let excess_amount = amount.saturating_sub(threshold);
+
+    let mut breakdown = Vec::with_capacity(if excess_amount > 0 { 2 } else { 1 });
+    let base_tax = apply_rate(base_amount, base_rate_numer, base_rate_denom, policy)?;
+    breakdown.push(WithholdingTaxStep {
+        label: format!("{}円以下の部分", threshold),
+        base_amount,
+        rate_numer: base_rate_numer,
+        rate_denom: base_rate_denom,
+        result: base_tax,
+    });
+
+    let mut total_tax = base_tax.as_yen();
+
+    if excess_amount > 0 {
+        let excess_tax = apply_rate(excess_amount, excess_rate_numer, excess_rate_denom, policy)?;
+        total_tax = total_tax.checked_add(excess_tax.as_yen()).ok_or_else(|| {
+            CalculationError::Overflow {
+                step: "withholding_tax_total".into(),
+            }
+        })?;
+        breakdown.push(WithholdingTaxStep {
+            label: format!("{}円超の部分", threshold),
+            base_amount: excess_amount,
+            rate_numer: excess_rate_numer,
+            rate_denom: excess_rate_denom,
+            result: excess_tax,
+        });
+    }
+
+    Ok((FinalAmount::new(total_tax), breakdown))
+}
+
+fn apply_rate(
+    amount: u64,
+    rate_numer: u64,
+    rate_denom: u64,
+    policy: &dyn WithholdingTaxPolicy,
+) -> Result<FinalAmount, JLawError> {
+    let rate = Rate::new(rate_numer, rate_denom).map_err(|_| CalculationError::Overflow {
+        step: "withholding_tax_rate".into(),
+    })?;
+    let rounding = policy.tax_rounding();
+    Ok(rate
+        .apply(
+            &IntermediateAmount::from_exact(amount),
+            MultiplyOrder::MultiplyFirst,
+            rounding,
+        )?
+        .finalize(rounding)?)
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+    use crate::domains::withholding_tax::params::WithholdingTaxCategoryParams;
+    use crate::domains::withholding_tax::policy::StandardWithholdingTaxPolicy;
+
+    #[test]
+    fn zero_amount_returns_zero() {
+        let params = WithholdingTaxParams {
+            categories: vec![WithholdingTaxCategoryParams {
+                category: WithholdingTaxCategory::ProfessionalFee,
+                label: "税理士等の報酬".into(),
+                method: WithholdingTaxMethod::TwoTier {
+                    threshold: 1_000_000,
+                    base_rate_numer: 1021,
+                    base_rate_denom: 10_000,
+                    excess_rate_numer: 2042,
+                    excess_rate_denom: 10_000,
+                },
+                submission_prize_exemption_threshold: None,
+            }],
+        };
+        let ctx = WithholdingTaxContext {
+            payment_amount: 0,
+            separated_consumption_tax_amount: 0,
+            category: WithholdingTaxCategory::ProfessionalFee,
+            target_date: crate::LegalDate::new(2026, 1, 1),
+            flags: HashSet::new(),
+            policy: Box::new(StandardWithholdingTaxPolicy),
+        };
+
+        let result = calculate_withholding_tax(&ctx, &params).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 0);
+        assert_eq!(result.net_payment_amount.as_yen(), 0);
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/withholding_tax/context.rs

@@ -0,0 +1,167 @@
+use std::collections::HashSet;
+use std::fmt;
+use std::str::FromStr;
+
+use crate::domains::withholding_tax::policy::WithholdingTaxPolicy;
+use crate::error::InputError;
+use crate::types::date::LegalDate;
+
+/// 報酬・料金等の源泉徴収カテゴリ。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum WithholdingTaxCategory {
+    /// 原稿料・講演料等。
+    ///
+    /// # 法的根拠
+    /// 所得税法 第204条第1項第1号
+    ManuscriptAndLecture,
+    /// 弁護士・税理士・公認会計士等の報酬・料金。
+    ///
+    /// # 法的根拠
+    /// 所得税法 第204条第1項第2号
+    ProfessionalFee,
+    /// 役務の提供等を約することにより一時に支払う契約金。
+    ///
+    /// # 法的根拠
+    /// 所得税法 第204条第1項第7号
+    ExclusiveContractFee,
+}
+
+impl WithholdingTaxCategory {
+    /// 永続化・バインディング用のコード文字列。
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::ManuscriptAndLecture => "manuscript_and_lecture",
+            Self::ProfessionalFee => "professional_fee",
+            Self::ExclusiveContractFee => "exclusive_contract_fee",
+        }
+    }
+
+    /// C ABI 用の整数コード。
+    pub fn ffi_code(self) -> u32 {
+        match self {
+            Self::ManuscriptAndLecture => 1,
+            Self::ProfessionalFee => 2,
+            Self::ExclusiveContractFee => 3,
+        }
+    }
+
+    /// C ABI から整数コードを復元する。
+    pub fn from_ffi_code(code: u32) -> Result<Self, InputError> {
+        match code {
+            1 => Ok(Self::ManuscriptAndLecture),
+            2 => Ok(Self::ProfessionalFee),
+            3 => Ok(Self::ExclusiveContractFee),
+            _ => Err(InputError::InvalidWithholdingInput {
+                field: "category".into(),
+                reason: format!("未知のカテゴリコードです: {code}"),
+            }),
+        }
+    }
+}
+
+impl fmt::Display for WithholdingTaxCategory {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+impl From<WithholdingTaxCategory> for u32 {
+    fn from(value: WithholdingTaxCategory) -> Self {
+        value.ffi_code()
+    }
+}
+
+impl FromStr for WithholdingTaxCategory {
+    type Err = InputError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "manuscript_and_lecture" => Ok(Self::ManuscriptAndLecture),
+            "professional_fee" => Ok(Self::ProfessionalFee),
+            "exclusive_contract_fee" => Ok(Self::ExclusiveContractFee),
+            _ => Err(InputError::InvalidWithholdingInput {
+                field: "category".into(),
+                reason: format!("未知のカテゴリです: {s}"),
+            }),
+        }
+    }
+}
+
+/// 源泉徴収税額の計算に影響するフラグ。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項第1号
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum WithholdingTaxFlag {
+    /// 応募作品等の入選者に支払う賞金・謝金として扱う。
+    ///
+    /// 原稿料・講演料等のうち、1回の支払額が50,000円以下である場合は
+    /// 源泉徴収不要となる。
+    ///
+    /// WARNING: このフラグの事実認定はライブラリの責任範囲外です。
+    /// 呼び出し元が正しく判断した上で指定してください。
+    IsSubmissionPrize,
+}
+
+/// 報酬・料金等の源泉徴収税額計算コンテキスト。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+pub struct WithholdingTaxContext {
+    /// 実際に支払う総額（円）。
+    ///
+    /// 請求書等で消費税額が区分表示されている場合でも、
+    /// ここには支払総額を指定する。
+    pub payment_amount: u64,
+    /// 請求書等で区分表示された消費税額（円）。
+    ///
+    /// 0 の場合は区分表示なしとして扱う。
+    pub separated_consumption_tax_amount: u64,
+    /// 報酬・料金等のカテゴリ。
+    pub category: WithholdingTaxCategory,
+    /// 計算対象日。
+    pub target_date: LegalDate,
+    /// 適用フラグ。
+    pub flags: HashSet<WithholdingTaxFlag>,
+    /// 端数処理・特例判定ポリシー。
+    pub policy: Box<dyn WithholdingTaxPolicy>,
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+    use crate::domains::withholding_tax::policy::StandardWithholdingTaxPolicy;
+
+    #[test]
+    fn category_string_roundtrip() {
+        let category = WithholdingTaxCategory::from_str("professional_fee").unwrap();
+        assert_eq!(category, WithholdingTaxCategory::ProfessionalFee);
+        assert_eq!(category.as_str(), "professional_fee");
+    }
+
+    #[test]
+    fn category_ffi_roundtrip() {
+        let category = WithholdingTaxCategory::from_ffi_code(3).unwrap();
+        assert_eq!(category, WithholdingTaxCategory::ExclusiveContractFee);
+        assert_eq!(category.ffi_code(), 3);
+    }
+
+    #[test]
+    fn context_construction() {
+        let ctx = WithholdingTaxContext {
+            payment_amount: 100_000,
+            separated_consumption_tax_amount: 10_000,
+            category: WithholdingTaxCategory::ManuscriptAndLecture,
+            target_date: LegalDate::new(2026, 1, 1),
+            flags: HashSet::new(),
+            policy: Box::new(StandardWithholdingTaxPolicy),
+        };
+
+        assert_eq!(ctx.payment_amount, 100_000);
+        assert_eq!(ctx.separated_consumption_tax_amount, 10_000);
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/withholding_tax/mod.rs

@@ -0,0 +1,9 @@
+pub mod calculator;
+pub mod context;
+pub mod params;
+pub mod policy;
+
+pub use calculator::{calculate_withholding_tax, WithholdingTaxResult, WithholdingTaxStep};
+pub use context::{WithholdingTaxCategory, WithholdingTaxContext, WithholdingTaxFlag};
+pub use params::{WithholdingTaxCategoryParams, WithholdingTaxMethod, WithholdingTaxParams};
+pub use policy::StandardWithholdingTaxPolicy;

data/vendor/rust/crates/j-law-core/src/domains/withholding_tax/params.rs

@@ -0,0 +1,80 @@
+use crate::domains::withholding_tax::context::WithholdingTaxCategory;
+
+/// 源泉徴収カテゴリごとの計算方式。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+#[derive(Debug, Clone)]
+pub enum WithholdingTaxMethod {
+    /// 100万円以下部分と超過部分で税率が異なる二段階計算。
+    ///
+    /// 令和8年（2026年）3月11日時点の国税庁資料では
+    /// 10.21% / 20.42% の二段階税率で運用されている。
+    TwoTier {
+        threshold: u64,
+        base_rate_numer: u64,
+        base_rate_denom: u64,
+        excess_rate_numer: u64,
+        excess_rate_denom: u64,
+    },
+}
+
+/// 源泉徴収カテゴリ1件分のパラメータ。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+#[derive(Debug, Clone)]
+pub struct WithholdingTaxCategoryParams {
+    /// 対象カテゴリ。
+    pub category: WithholdingTaxCategory,
+    /// 表示用ラベル。
+    pub label: String,
+    /// 税額計算方式。
+    pub method: WithholdingTaxMethod,
+    /// 応募作品等の入選賞金・謝金の非課税しきい値。
+    ///
+    /// 該当しないカテゴリでは `None`。
+    pub submission_prize_exemption_threshold: Option<u64>,
+}
+
+/// 源泉徴収税額計算に使うパラメータセット。
+///
+/// `j-law-registry` が JSON からロードしてこの型に変換する。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+#[derive(Debug, Clone)]
+pub struct WithholdingTaxParams {
+    /// カテゴリごとの計算パラメータ。
+    pub categories: Vec<WithholdingTaxCategoryParams>,
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn params_construction() {
+        let params = WithholdingTaxParams {
+            categories: vec![WithholdingTaxCategoryParams {
+                category: WithholdingTaxCategory::ManuscriptAndLecture,
+                label: "原稿料・講演料等".into(),
+                method: WithholdingTaxMethod::TwoTier {
+                    threshold: 1_000_000,
+                    base_rate_numer: 1021,
+                    base_rate_denom: 10_000,
+                    excess_rate_numer: 2042,
+                    excess_rate_denom: 10_000,
+                },
+                submission_prize_exemption_threshold: Some(50_000),
+            }],
+        };
+
+        assert_eq!(params.categories.len(), 1);
+        assert_eq!(
+            params.categories[0].submission_prize_exemption_threshold,
+            Some(50_000)
+        );
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/withholding_tax/policy.rs

@@ -0,0 +1,49 @@
+use std::collections::HashSet;
+
+use crate::domains::withholding_tax::context::{WithholdingTaxCategory, WithholdingTaxFlag};
+use crate::types::rounding::RoundingStrategy;
+
+/// 源泉徴収税額計算のポリシーインターフェース。
+///
+/// 通常は [`StandardWithholdingTaxPolicy`] を使う。
+pub trait WithholdingTaxPolicy: std::fmt::Debug {
+    /// 税額計算に使う端数処理戦略。
+    fn tax_rounding(&self) -> RoundingStrategy;
+
+    /// 応募作品等の入選賞金・謝金に対する非課税特例を適用するか判定する。
+    fn should_apply_submission_prize_exemption(
+        &self,
+        category: WithholdingTaxCategory,
+        taxable_payment_amount: u64,
+        flags: &HashSet<WithholdingTaxFlag>,
+        exemption_threshold: Option<u64>,
+    ) -> bool;
+}
+
+/// 国税庁の標準解釈に基づく源泉徴収税額計算ポリシー。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+/// 東日本大震災からの復興のための施策を実施するために必要な財源の確保に関する特別措置法
+#[derive(Debug, Clone, Copy)]
+pub struct StandardWithholdingTaxPolicy;
+
+impl WithholdingTaxPolicy for StandardWithholdingTaxPolicy {
+    fn tax_rounding(&self) -> RoundingStrategy {
+        RoundingStrategy::Floor
+    }
+
+    fn should_apply_submission_prize_exemption(
+        &self,
+        category: WithholdingTaxCategory,
+        taxable_payment_amount: u64,
+        flags: &HashSet<WithholdingTaxFlag>,
+        exemption_threshold: Option<u64>,
+    ) -> bool {
+        category == WithholdingTaxCategory::ManuscriptAndLecture
+            && flags.contains(&WithholdingTaxFlag::IsSubmissionPrize)
+            && exemption_threshold
+                .map(|threshold| taxable_payment_amount <= threshold)
+                .unwrap_or(false)
+    }
+}