feat(fundamental): add economic_indicator_list and economic_indicator

java/javasrc/src/main/java/com/longbridge/SdkNative.java

@@ -451,6 +451,14 @@ public static native void fundamentalContextGetFinancialReportSnapshot(long cont
                         Object opts,
                         AsyncCallback callback);
 
+        public static native void fundamentalContextMacrodataIndicators(long context,
+                        Object offset, Object limit,
+                        AsyncCallback callback);
+
+        public static native void fundamentalContextMacrodata(long context,
+                        Object indicatorCode, Object startTime, Object endTime, Object limit,
+                        AsyncCallback callback);
+
         public static native void portfolioContextProfitAnalysisFlows(long context, Object opts,
                         AsyncCallback callback);
 

java/javasrc/src/main/java/com/longbridge/fundamental/EconomicIndicatorData.java

@@ -0,0 +1,15 @@
+package com.longbridge.fundamental;
+
+/** One historical data point for a macroeconomic indicator. */
+public class EconomicIndicatorData {
+    /** Statistical period (e.g. 2024-Q1, 2024-03). */
+    public String period;
+    public String releaseAt;
+    public String actualValue;
+    public String previousValue;
+    public String forecastValue;
+    public String revisedValue;
+    public String nextReleaseAt;
+    public MultiLanguageText unit;
+    public MultiLanguageText unitPrefix;
+}

java/javasrc/src/main/java/com/longbridge/fundamental/EconomicIndicatorInfo.java

@@ -0,0 +1,19 @@
+package com.longbridge.fundamental;
+
+/** Metadata for one macroeconomic indicator. */
+public class EconomicIndicatorInfo {
+    /** External vendor code (input to getEconomicIndicator). */
+    public String indicatorCode;
+    public String sourceOrg;
+    public String country;
+    public MultiLanguageText name;
+    public String adjustmentFactor;
+    /** Release periodicity (e.g. monthly / quarterly). */
+    public String periodicity;
+    public String category;
+    public MultiLanguageText describe;
+    /** Importance — higher is more important. */
+    public int importance;
+    /** Start date of data coverage (unix timestamp string). */
+    public String startDate;
+}

java/javasrc/src/main/java/com/longbridge/fundamental/EconomicIndicatorResponse.java

@@ -0,0 +1,7 @@
+package com.longbridge.fundamental;
+
+/** Response for {@link FundamentalContext#getEconomicIndicator}. */
+public class EconomicIndicatorResponse {
+    public EconomicIndicatorInfo info;
+    public EconomicIndicatorData[] data;
+}

java/javasrc/src/main/java/com/longbridge/fundamental/FundamentalContext.java

@@ -334,4 +334,18 @@ public CompletableFuture<ValuationComparisonResponse> getValuationComparison(Val
             SdkNative.fundamentalContextValuationComparison(raw, opts, callback);
         });
     }
+
+    /** List macroeconomic indicators. */
+    public CompletableFuture<EconomicIndicatorInfo[]> getMacrodataIndicators(Integer offset, Integer limit) throws OpenApiException {
+        return AsyncCallback.executeTask((callback) -> {
+            SdkNative.fundamentalContextMacrodataIndicators(raw, offset, limit, callback);
+        });
+    }
+
+    /** Get historical data for a macroeconomic indicator. */
+    public CompletableFuture<EconomicIndicatorResponse> getMacrodata(String indicatorCode, java.time.OffsetDateTime startTime, java.time.OffsetDateTime endTime, Integer limit) throws OpenApiException {
+        return AsyncCallback.executeTask((callback) -> {
+            SdkNative.fundamentalContextMacrodata(raw, indicatorCode, startTime, endTime, limit, callback);
+        });
+    }
 }

java/javasrc/src/main/java/com/longbridge/fundamental/MultiLanguageText.java

@@ -0,0 +1,8 @@
+package com.longbridge.fundamental;
+
+/** Localized text in simplified Chinese, traditional Chinese, and English. */
+public class MultiLanguageText {
+    public String english;
+    public String simplifiedChinese;
+    public String traditionalChinese;
+}

java/src/fundamental_context.rs

@@ -262,3 +262,55 @@ pub unsafe extern "system" fn Java_com_longbridge_SdkNative_fundamentalContextVa
         Ok(())
     })
 }
+
+#[unsafe(no_mangle)]
+pub unsafe extern "system" fn Java_com_longbridge_SdkNative_fundamentalContextMacrodataIndicators(
+    mut env: JNIEnv,
+    _class: JClass,
+    context: i64,
+    offset: JObject,
+    limit: JObject,
+    callback: JObject,
+) {
+    jni_result(&mut env, (), |env| {
+        let context = &*(context as *const ContextObj);
+        let offset: Option<i32> = FromJValue::from_jvalue(env, offset.into())?;
+        let limit: Option<i32> = FromJValue::from_jvalue(env, limit.into())?;
+        async_util::execute(env, callback, async move {
+            Ok(context
+                .ctx
+                .economic_indicator_list(offset, limit)
+                .await?)
+        })?;
+        Ok(())
+    })
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "system" fn Java_com_longbridge_SdkNative_fundamentalContextMacrodata(
+    mut env: JNIEnv,
+    _class: JClass,
+    context: i64,
+    indicator_code: JObject,
+    start_time: JObject,
+    end_time: JObject,
+    limit: JObject,
+    callback: JObject,
+) {
+    jni_result(&mut env, (), |env| {
+        let context = &*(context as *const ContextObj);
+        let indicator_code: String = FromJValue::from_jvalue(env, indicator_code.into())?;
+        let start_time: Option<time::OffsetDateTime> =
+            FromJValue::from_jvalue(env, start_time.into())?;
+        let end_time: Option<time::OffsetDateTime> =
+            FromJValue::from_jvalue(env, end_time.into())?;
+        let limit: Option<i32> = FromJValue::from_jvalue(env, limit.into())?;
+        async_util::execute(env, callback, async move {
+            Ok(context
+                .ctx
+                .macrodata(indicator_code, start_time, end_time, limit)
+                .await?)
+        })?;
+        Ok(())
+    })
+}

java/src/types/classes.rs

@@ -2698,6 +2698,55 @@ impl_java_class!(
     ]
 );
 
+impl_java_class!(
+    "com/longbridge/fundamental/MultiLanguageText",
+    longbridge::fundamental::MultiLanguageText,
+    [english, simplified_chinese, traditional_chinese]
+);
+
+impl_java_class!(
+    "com/longbridge/fundamental/EconomicIndicatorInfo",
+    longbridge::fundamental::EconomicIndicatorInfo,
+    [
+        indicator_code,
+        source_org,
+        country,
+        name,
+        adjustment_factor,
+        periodicity,
+        category,
+        describe,
+        importance,
+        start_date
+    ]
+);
+
+impl_java_class!(
+    "com/longbridge/fundamental/EconomicIndicatorData",
+    longbridge::fundamental::EconomicIndicatorData,
+    [
+        period,
+        release_at,
+        actual_value,
+        previous_value,
+        forecast_value,
+        revised_value,
+        next_release_at,
+        unit,
+        unit_prefix
+    ]
+);
+
+impl_java_class!(
+    "com/longbridge/fundamental/EconomicIndicatorResponse",
+    longbridge::fundamental::EconomicIndicatorResponse,
+    [
+        info,
+        #[java(objarray)]
+        data
+    ]
+);
+
 // ── MarketContext: top movers / rank ──────────────────────────────
 
 impl_java_class!(

nodejs/index.d.ts

@@ -618,6 +618,10 @@ export declare class FundamentalContext {
    * industry)
    */
   etfAssetAllocation(symbol: string): Promise<AssetAllocationResponse>
+  /** List macroeconomic indicators */
+  macrodataIndicators(offset?: number | null, limit?: number | null): Promise<Array<EconomicIndicatorInfo>>
+  /** Get historical data for a macroeconomic indicator */
+  macrodata(indicatorCode: string, startTime?: bigint | null, endTime?: bigint | null, limit?: number | null): Promise<EconomicIndicatorResponse>
 }
 
 /** Fund position */
@@ -3133,6 +3137,45 @@ export interface AssetAllocationResponse {
   /** Asset allocation groups */
   info: Array<AssetAllocationGroup>
 }
+/** Localized text in simplified Chinese, traditional Chinese, and English */
+export interface MultiLanguageText {
+  english: string
+  simplifiedChinese: string
+  traditionalChinese: string
+}
+/** Metadata for one macroeconomic indicator */
+export interface EconomicIndicatorInfo {
+  indicatorCode: string
+  sourceOrg: string
+  country: string
+  name: MultiLanguageText
+  adjustmentFactor: string
+  periodicity: string
+  category: string
+  describe: MultiLanguageText
+  importance: number
+  /** Start date of data coverage (unix timestamp in seconds; null if unset) */
+  startDate: bigint | null
+}
+/** One historical data point for a macroeconomic indicator */
+export interface EconomicIndicatorData {
+  period: string
+  /** Release datetime (unix timestamp in seconds; null if unset) */
+  releaseAt: bigint | null
+  actualValue: string
+  previousValue: string
+  forecastValue: string
+  revisedValue: string
+  /** Next release datetime (unix timestamp in seconds; null if unset) */
+  nextReleaseAt: bigint | null
+  unit: MultiLanguageText
+  unitPrefix: MultiLanguageText
+}
+/** Response for macrodata */
+export interface EconomicIndicatorResponse {
+  info: EconomicIndicatorInfo
+  data: Array<EconomicIndicatorData>
+}
 
 export declare const enum AssetType {
   /** Unknown */

nodejs/src/fundamental/context.rs

@@ -287,4 +287,50 @@ impl FundamentalContext {
             .map_err(ErrorNewType)?
             .into())
     }
+
+    /// List macroeconomic indicators
+    #[napi]
+    pub async fn macrodata_indicators(
+        &self,
+        offset: Option<i32>,
+        limit: Option<i32>,
+    ) -> Result<Vec<EconomicIndicatorInfo>> {
+        Ok(self
+            .ctx
+            .macrodata_indicators(offset, limit)
+            .await
+            .map_err(ErrorNewType)?
+            .into_iter()
+            .map(Into::into)
+            .collect())
+    }
+
+    /// Get historical data for a macroeconomic indicator
+    #[napi]
+    pub async fn macrodata(
+        &self,
+        indicator_code: String,
+        start_time: Option<i64>,
+        end_time: Option<i64>,
+        limit: Option<i32>,
+    ) -> Result<EconomicIndicatorResponse> {
+        use time::OffsetDateTime;
+        Ok(self
+            .ctx
+            .macrodata(
+                indicator_code,
+                start_time
+                    .map(OffsetDateTime::from_unix_timestamp)
+                    .transpose()
+                    .map_err(|e| napi::Error::from_reason(e.to_string()))?,
+                end_time
+                    .map(OffsetDateTime::from_unix_timestamp)
+                    .transpose()
+                    .map_err(|e| napi::Error::from_reason(e.to_string()))?,
+                limit,
+            )
+            .await
+            .map_err(ErrorNewType)?
+            .into())
+    }
 }