@aetherwealth/sdk 0.1.32

package/dist/schemas.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Opt-in Zod parsers for aether-backend response shapes (camelCase). Compile-
+ * time safety comes from `types.ts`; import these only when you want runtime
+ * validation of untrusted responses:
+ *
+ * ```ts
+ * import {parseTrade} from '@aetherwealth/sdk'
+ * const trade = parseTrade(await client.trades.get(id))
+ * ```
+ *
+ * Schemas mirror the backend Zod schemas (the source of truth) and are
+ * `.passthrough()`-tolerant so a backend that adds a field doesn't break
+ * older SDK consumers.
+ */
+import { z } from 'zod';
+export declare const tradeDirectionSchema: z.ZodEnum<{
+    LONG: "LONG";
+    SHORT: "SHORT";
+}>;
+export declare const tradeStatusSchema: z.ZodEnum<{
+    OPEN: "OPEN";
+    CLOSED: "CLOSED";
+    CANCELLED: "CANCELLED";
+}>;
+export declare const tradeSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    accountId: z.ZodString;
+    pair: z.ZodString;
+    direction: z.ZodEnum<{
+        LONG: "LONG";
+        SHORT: "SHORT";
+    }>;
+    entryPrice: z.ZodNumber;
+    exitPrice: z.ZodNullable<z.ZodNumber>;
+    stopLoss: z.ZodNullable<z.ZodNumber>;
+    takeProfit: z.ZodNullable<z.ZodNumber>;
+    lotSize: z.ZodNumber;
+    entryTime: z.ZodString;
+    exitTime: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSED: "CLOSED";
+        CANCELLED: "CANCELLED";
+    }>;
+    pnl: z.ZodNullable<z.ZodNumber>;
+    pnlPercent: z.ZodNullable<z.ZodNumber>;
+    pnlPips: z.ZodNullable<z.ZodNumber>;
+    fees: z.ZodNumber;
+    swap: z.ZodNumber;
+    notes: z.ZodNullable<z.ZodString>;
+    setupNotes: z.ZodNullable<z.ZodString>;
+    emotionalTag: z.ZodNullable<z.ZodString>;
+    timeframe: z.ZodNullable<z.ZodString>;
+    screenshotUrl: z.ZodNullable<z.ZodString>;
+    riskPercent: z.ZodNullable<z.ZodNumber>;
+    initialRisk: z.ZodNullable<z.ZodNumber>;
+    rMultiple: z.ZodNullable<z.ZodNumber>;
+    notesFormat: z.ZodNullable<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export declare const accountSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    name: z.ZodString;
+    broker: z.ZodNullable<z.ZodString>;
+    accountType: z.ZodString;
+    initialBalance: z.ZodNumber;
+    currency: z.ZodString;
+    notes: z.ZodNullable<z.ZodString>;
+    isActive: z.ZodBoolean;
+    defaultRiskAmount: z.ZodNullable<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export declare const tradingStatsSchema: z.ZodObject<{
+    totalTrades: z.ZodNumber;
+    winRate: z.ZodNumber;
+    profitFactor: z.ZodNumber;
+    totalPnl: z.ZodNumber;
+    totalPnlPips: z.ZodNumber;
+    avgWin: z.ZodNumber;
+    avgLoss: z.ZodNumber;
+    maxDrawdown: z.ZodNumber;
+    sharpeRatio: z.ZodNullable<z.ZodNumber>;
+    riskRewardAvg: z.ZodNullable<z.ZodNumber>;
+    bestPair: z.ZodNullable<z.ZodString>;
+    worstPair: z.ZodNullable<z.ZodString>;
+    avgHoldTimeMinutes: z.ZodNumber;
+    avgR: z.ZodNullable<z.ZodNumber>;
+    expectancyR: z.ZodNullable<z.ZodNumber>;
+    sqn: z.ZodNullable<z.ZodNumber>;
+    consecutiveWins: z.ZodNumber;
+    consecutiveLosses: z.ZodNumber;
+}, z.core.$loose>;
+export declare const priceConditionSchema: z.ZodEnum<{
+    above: "above";
+    below: "below";
+    crosses: "crosses";
+}>;
+export declare const triggerTypeSchema: z.ZodEnum<{
+    close: "close";
+    wick: "wick";
+}>;
+export declare const dedupModeSchema: z.ZodEnum<{
+    edge: "edge";
+    continuous: "continuous";
+}>;
+export declare const alertSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    pair: z.ZodString;
+    timeframe: z.ZodString;
+    alertType: z.ZodEnum<{
+        price: "price";
+        trendline: "trendline";
+    }>;
+    price: z.ZodNullable<z.ZodNumber>;
+    price1: z.ZodNullable<z.ZodNumber>;
+    time1: z.ZodNullable<z.ZodString>;
+    price2: z.ZodNullable<z.ZodNumber>;
+    time2: z.ZodNullable<z.ZodString>;
+    slope: z.ZodNullable<z.ZodNumber>;
+    intercept: z.ZodNullable<z.ZodNumber>;
+    condition: z.ZodNullable<z.ZodEnum<{
+        above: "above";
+        below: "below";
+        crosses: "crosses";
+    }>>;
+    triggerType: z.ZodEnum<{
+        close: "close";
+        wick: "wick";
+    }>;
+    isPersistent: z.ZodBoolean;
+    isActive: z.ZodBoolean;
+    isArchived: z.ZodBoolean;
+    notifyEmail: z.ZodBoolean;
+    notifyPush: z.ZodBoolean;
+    message: z.ZodNullable<z.ZodString>;
+    triggeredAt: z.ZodNullable<z.ZodString>;
+    triggeredPrice: z.ZodNullable<z.ZodNumber>;
+    triggerCount: z.ZodNumber;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export declare const indicatorConditionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    op: z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        eq: "eq";
+        crosses_above: "crosses_above";
+        crosses_below: "crosses_below";
+    }>;
+    threshold: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodEnum<{
+        gt_series: "gt_series";
+        lt_series: "lt_series";
+        crosses_above_series: "crosses_above_series";
+        crosses_below_series: "crosses_below_series";
+    }>;
+    other: z.ZodString;
+}, z.core.$strip>]>;
+export declare const indicatorAlertSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    pair: z.ZodString;
+    timeframe: z.ZodString;
+    indicatorType: z.ZodString;
+    indicatorParams: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    customIndicatorId: z.ZodNullable<z.ZodString>;
+    customIndicatorVersion: z.ZodNullable<z.ZodNumber>;
+    outputSeries: z.ZodNullable<z.ZodString>;
+    condition: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        op: z.ZodEnum<{
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            eq: "eq";
+            crosses_above: "crosses_above";
+            crosses_below: "crosses_below";
+        }>;
+        threshold: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodEnum<{
+            gt_series: "gt_series";
+            lt_series: "lt_series";
+            crosses_above_series: "crosses_above_series";
+            crosses_below_series: "crosses_below_series";
+        }>;
+        other: z.ZodString;
+    }, z.core.$strip>]>>;
+    triggerType: z.ZodEnum<{
+        close: "close";
+        wick: "wick";
+    }>;
+    dedupMode: z.ZodEnum<{
+        edge: "edge";
+        continuous: "continuous";
+    }>;
+    isActive: z.ZodBoolean;
+    isArchived: z.ZodBoolean;
+    isTriggered: z.ZodBoolean;
+    isPersistent: z.ZodBoolean;
+    notifyEmail: z.ZodBoolean;
+    notifyPush: z.ZodBoolean;
+    message: z.ZodNullable<z.ZodString>;
+    triggeredAt: z.ZodNullable<z.ZodString>;
+    triggeredPrice: z.ZodNullable<z.ZodNumber>;
+    triggerCount: z.ZodNumber;
+    lastConditionState: z.ZodNullable<z.ZodString>;
+    lastTriggeredValue: z.ZodNullable<z.ZodNumber>;
+    lastEvaluatedAt: z.ZodNullable<z.ZodString>;
+    lastError: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export declare const diaryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    date: z.ZodString;
+    content: z.ZodString;
+    mood: z.ZodNullable<z.ZodString>;
+    rating: z.ZodNullable<z.ZodNumber>;
+    tags: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export declare const economicEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    currency: z.ZodString;
+    release: z.ZodString;
+    eventName: z.ZodString;
+    announcementUnix: z.ZodNumber;
+    impact: z.ZodNumber;
+    actual: z.ZodNullable<z.ZodNumber>;
+    forecast: z.ZodNullable<z.ZodNumber>;
+    previous: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const marketConfigSchema: z.ZodObject<{
+    supportedTAPairs: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    supportedFAPairs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    supportedTimeframes: z.ZodArray<z.ZodString>;
+    supportedFACurrencies: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+export declare const macroSeriesPointSchema: z.ZodObject<{
+    date: z.ZodString;
+    val: z.ZodNumber;
+    announcement_datetime: z.ZodNumber;
+}, z.core.$loose>;
+export declare const macroSeriesResultSchema: z.ZodObject<{
+    currency: z.ZodString;
+    indicator: z.ZodString;
+    unit: z.ZodOptional<z.ZodString>;
+    frequency: z.ZodOptional<z.ZodString>;
+    has_official_forecast: z.ZodOptional<z.ZodBoolean>;
+    series: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        val: z.ZodNumber;
+        announcement_datetime: z.ZodNumber;
+    }, z.core.$loose>>;
+    cb_target: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    cachedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const paginationSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+    total: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, z.core.$strip>;
+export declare const parseTrade: (value: unknown) => z.infer<typeof tradeSchema>;
+export declare const parseAccount: (value: unknown) => z.infer<typeof accountSchema>;
+export declare const parseTradingStats: (value: unknown) => z.infer<typeof tradingStatsSchema>;
+export declare const parseAlert: (value: unknown) => z.infer<typeof alertSchema>;
+export declare const parseIndicatorAlert: (value: unknown) => z.infer<typeof indicatorAlertSchema>;
+export declare const parseDiaryEntry: (value: unknown) => z.infer<typeof diaryEntrySchema>;
+export declare const parseEconomicEvent: (value: unknown) => z.infer<typeof economicEventSchema>;
+export declare const parseMarketConfig: (value: unknown) => z.infer<typeof marketConfigSchema>;
+/** `market.macro` resolves `null` when the backend has no series — pass it through. */
+export declare const parseMacroSeriesResult: (value: unknown) => z.infer<typeof macroSeriesResultSchema> | null;

package/dist/schemas.js

@@ -0,0 +1,239 @@
+/**
+ * Opt-in Zod parsers for aether-backend response shapes (camelCase). Compile-
+ * time safety comes from `types.ts`; import these only when you want runtime
+ * validation of untrusted responses:
+ *
+ * ```ts
+ * import {parseTrade} from '@aetherwealth/sdk'
+ * const trade = parseTrade(await client.trades.get(id))
+ * ```
+ *
+ * Schemas mirror the backend Zod schemas (the source of truth) and are
+ * `.passthrough()`-tolerant so a backend that adds a field doesn't break
+ * older SDK consumers.
+ */
+import { z } from 'zod';
+export const tradeDirectionSchema = z.enum(['LONG', 'SHORT']);
+export const tradeStatusSchema = z.enum(['OPEN', 'CLOSED', 'CANCELLED']);
+export const tradeSchema = z
+    .object({
+    id: z.string(),
+    userId: z.string(),
+    accountId: z.string(),
+    pair: z.string(),
+    direction: tradeDirectionSchema,
+    entryPrice: z.number(),
+    exitPrice: z.number().nullable(),
+    stopLoss: z.number().nullable(),
+    takeProfit: z.number().nullable(),
+    lotSize: z.number(),
+    entryTime: z.string(),
+    exitTime: z.string().nullable(),
+    status: tradeStatusSchema,
+    pnl: z.number().nullable(),
+    pnlPercent: z.number().nullable(),
+    pnlPips: z.number().nullable(),
+    fees: z.number(),
+    swap: z.number(),
+    notes: z.string().nullable(),
+    setupNotes: z.string().nullable(),
+    emotionalTag: z.string().nullable(),
+    timeframe: z.string().nullable(),
+    screenshotUrl: z.string().nullable(),
+    riskPercent: z.number().nullable(),
+    initialRisk: z.number().nullable(),
+    rMultiple: z.number().nullable(),
+    notesFormat: z.string().nullable(),
+    tags: z.array(z.string()),
+    createdAt: z.string(),
+    updatedAt: z.string()
+})
+    .passthrough();
+export const accountSchema = z
+    .object({
+    id: z.string(),
+    userId: z.string(),
+    name: z.string(),
+    broker: z.string().nullable(),
+    accountType: z.string(),
+    initialBalance: z.number(),
+    currency: z.string(),
+    notes: z.string().nullable(),
+    isActive: z.boolean(),
+    defaultRiskAmount: z.number().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+})
+    .passthrough();
+export const tradingStatsSchema = z
+    .object({
+    totalTrades: z.number(),
+    winRate: z.number(),
+    profitFactor: z.number(),
+    totalPnl: z.number(),
+    totalPnlPips: z.number(),
+    avgWin: z.number(),
+    avgLoss: z.number(),
+    maxDrawdown: z.number(),
+    sharpeRatio: z.number().nullable(),
+    riskRewardAvg: z.number().nullable(),
+    bestPair: z.string().nullable(),
+    worstPair: z.string().nullable(),
+    avgHoldTimeMinutes: z.number(),
+    avgR: z.number().nullable(),
+    expectancyR: z.number().nullable(),
+    sqn: z.number().nullable(),
+    consecutiveWins: z.number(),
+    consecutiveLosses: z.number()
+})
+    .passthrough();
+export const priceConditionSchema = z.enum(['above', 'below', 'crosses']);
+export const triggerTypeSchema = z.enum(['close', 'wick']);
+export const dedupModeSchema = z.enum(['edge', 'continuous']);
+export const alertSchema = z
+    .object({
+    id: z.string(),
+    userId: z.string(),
+    pair: z.string(),
+    timeframe: z.string(),
+    alertType: z.enum(['price', 'trendline']),
+    price: z.number().nullable(),
+    price1: z.number().nullable(),
+    time1: z.string().nullable(),
+    price2: z.number().nullable(),
+    time2: z.string().nullable(),
+    slope: z.number().nullable(),
+    intercept: z.number().nullable(),
+    condition: priceConditionSchema.nullable(),
+    triggerType: triggerTypeSchema,
+    isPersistent: z.boolean(),
+    isActive: z.boolean(),
+    isArchived: z.boolean(),
+    notifyEmail: z.boolean(),
+    notifyPush: z.boolean(),
+    message: z.string().nullable(),
+    triggeredAt: z.string().nullable(),
+    triggeredPrice: z.number().nullable(),
+    triggerCount: z.number().int(),
+    expiresAt: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+})
+    .passthrough();
+export const indicatorConditionSchema = z.union([
+    z.object({
+        op: z.enum(['gt', 'gte', 'lt', 'lte', 'eq', 'crosses_above', 'crosses_below']),
+        threshold: z.number()
+    }),
+    z.object({
+        op: z.enum(['gt_series', 'lt_series', 'crosses_above_series', 'crosses_below_series']),
+        other: z.string()
+    })
+]);
+export const indicatorAlertSchema = z
+    .object({
+    id: z.string(),
+    userId: z.string(),
+    pair: z.string(),
+    timeframe: z.string(),
+    indicatorType: z.string(),
+    indicatorParams: z.record(z.string(), z.unknown()),
+    customIndicatorId: z.string().nullable(),
+    customIndicatorVersion: z.number().nullable(),
+    outputSeries: z.string().nullable(),
+    condition: indicatorConditionSchema.nullable(),
+    triggerType: triggerTypeSchema,
+    dedupMode: dedupModeSchema,
+    isActive: z.boolean(),
+    isArchived: z.boolean(),
+    isTriggered: z.boolean(),
+    isPersistent: z.boolean(),
+    notifyEmail: z.boolean(),
+    notifyPush: z.boolean(),
+    message: z.string().nullable(),
+    triggeredAt: z.string().nullable(),
+    triggeredPrice: z.number().nullable(),
+    triggerCount: z.number().int(),
+    lastConditionState: z.string().nullable(),
+    lastTriggeredValue: z.number().nullable(),
+    lastEvaluatedAt: z.string().nullable(),
+    lastError: z.string().nullable(),
+    expiresAt: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+})
+    .passthrough();
+export const diaryEntrySchema = z
+    .object({
+    id: z.string(),
+    date: z.string(),
+    content: z.string(),
+    mood: z.string().nullable(),
+    rating: z.number().nullable(),
+    tags: z.array(z.string()),
+    createdAt: z.string(),
+    updatedAt: z.string()
+})
+    .passthrough();
+export const economicEventSchema = z
+    .object({
+    id: z.string(),
+    currency: z.string(),
+    release: z.string(),
+    eventName: z.string(),
+    announcementUnix: z.number().int(),
+    impact: z.number().int(),
+    actual: z.number().nullable(),
+    forecast: z.number().nullable(),
+    previous: z.number().nullable()
+})
+    .passthrough();
+// Nested instrument-metadata keys stay snake_case (emitted literally by the
+// backend), so the record values are opaque blobs.
+export const marketConfigSchema = z
+    .object({
+    supportedTAPairs: z.record(z.string(), z.record(z.string(), z.unknown())),
+    supportedFAPairs: z.record(z.string(), z.unknown()),
+    supportedTimeframes: z.array(z.string()),
+    supportedFACurrencies: z.array(z.string())
+})
+    .passthrough();
+export const macroSeriesPointSchema = z
+    .object({
+    date: z.string(),
+    val: z.number(),
+    announcement_datetime: z.number()
+})
+    .passthrough();
+// fxmacrodata series forwarded untransformed — the snake_case fields match the
+// `MacroSeriesResult` wire type. `market.macro` may resolve `null` (no series);
+// the null case is handled by `parseMacroSeriesResult`, not the schema.
+export const macroSeriesResultSchema = z
+    .object({
+    currency: z.string(),
+    indicator: z.string(),
+    unit: z.string().optional(),
+    frequency: z.string().optional(),
+    has_official_forecast: z.boolean().optional(),
+    series: z.array(macroSeriesPointSchema),
+    cb_target: z.record(z.string(), z.unknown()).optional(),
+    cachedAt: z.number().optional()
+})
+    .passthrough();
+export const paginationSchema = z.object({
+    page: z.number(),
+    limit: z.number(),
+    total: z.number(),
+    totalPages: z.number()
+});
+// ── Opt-in parse helpers ─────────────────────────────────────────────────
+export const parseTrade = (value) => tradeSchema.parse(value);
+export const parseAccount = (value) => accountSchema.parse(value);
+export const parseTradingStats = (value) => tradingStatsSchema.parse(value);
+export const parseAlert = (value) => alertSchema.parse(value);
+export const parseIndicatorAlert = (value) => indicatorAlertSchema.parse(value);
+export const parseDiaryEntry = (value) => diaryEntrySchema.parse(value);
+export const parseEconomicEvent = (value) => economicEventSchema.parse(value);
+export const parseMarketConfig = (value) => marketConfigSchema.parse(value);
+/** `market.macro` resolves `null` when the backend has no series — pass it through. */
+export const parseMacroSeriesResult = (value) => value === null ? null : macroSeriesResultSchema.parse(value);