@adaptic/utils 0.1.49 → 0.1.50

package/dist/types/schemas/massive-schemas.d.ts

@@ -0,0 +1,561 @@
+/**
+ * Zod schemas for Massive.com API response validation.
+ * Validates API responses against expected shapes to catch breaking API changes early.
+ */
+import { z } from "zod";
+/** Schema for raw Massive price data (as returned from aggregates endpoint) */
+export declare const RawMassivePriceDataSchema: z.ZodObject<{
+    T: z.ZodString;
+    c: z.ZodNumber;
+    h: z.ZodNumber;
+    l: z.ZodNumber;
+    n: z.ZodNumber;
+    o: z.ZodNumber;
+    t: z.ZodNumber;
+    v: z.ZodNumber;
+    vw: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    t: number;
+    T: string;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v: number;
+    vw: number;
+    n: number;
+}, {
+    t: number;
+    T: string;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v: number;
+    vw: number;
+    n: number;
+}>;
+/** Schema for Massive ticker info response */
+export declare const MassiveTickerInfoSchema: z.ZodObject<{
+    active: z.ZodBoolean;
+    currency_name: z.ZodString;
+    delisted_utc: z.ZodOptional<z.ZodString>;
+    description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    locale: z.ZodString;
+    market: z.ZodEnum<["stocks", "crypto", "indices", "fx", "otc"]>;
+    market_cap: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    name: z.ZodString;
+    primary_exchange: z.ZodString;
+    share_class_shares_outstanding: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ticker: z.ZodString;
+    type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    market: "crypto" | "stocks" | "indices" | "fx" | "otc";
+    active: boolean;
+    description: string;
+    ticker: string;
+    currency_name: string;
+    locale: string;
+    name: string;
+    primary_exchange: string;
+    market_cap: number;
+    delisted_utc?: string | undefined;
+    share_class_shares_outstanding?: number | null | undefined;
+}, {
+    type: string;
+    market: "crypto" | "stocks" | "indices" | "fx" | "otc";
+    active: boolean;
+    ticker: string;
+    currency_name: string;
+    locale: string;
+    name: string;
+    primary_exchange: string;
+    description?: string | undefined;
+    delisted_utc?: string | undefined;
+    market_cap?: number | undefined;
+    share_class_shares_outstanding?: number | null | undefined;
+}>;
+/** Schema for the wrapper around ticker details API response */
+export declare const MassiveTickerDetailsResponseSchema: z.ZodObject<{
+    results: z.ZodObject<{
+        active: z.ZodBoolean;
+        currency_name: z.ZodString;
+        delisted_utc: z.ZodOptional<z.ZodString>;
+        description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        locale: z.ZodString;
+        market: z.ZodEnum<["stocks", "crypto", "indices", "fx", "otc"]>;
+        market_cap: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        name: z.ZodString;
+        primary_exchange: z.ZodString;
+        share_class_shares_outstanding: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        ticker: z.ZodString;
+        type: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        market: "crypto" | "stocks" | "indices" | "fx" | "otc";
+        active: boolean;
+        description: string;
+        ticker: string;
+        currency_name: string;
+        locale: string;
+        name: string;
+        primary_exchange: string;
+        market_cap: number;
+        delisted_utc?: string | undefined;
+        share_class_shares_outstanding?: number | null | undefined;
+    }, {
+        type: string;
+        market: "crypto" | "stocks" | "indices" | "fx" | "otc";
+        active: boolean;
+        ticker: string;
+        currency_name: string;
+        locale: string;
+        name: string;
+        primary_exchange: string;
+        description?: string | undefined;
+        delisted_utc?: string | undefined;
+        market_cap?: number | undefined;
+        share_class_shares_outstanding?: number | null | undefined;
+    }>;
+    status: z.ZodString;
+    request_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    results: {
+        type: string;
+        market: "crypto" | "stocks" | "indices" | "fx" | "otc";
+        active: boolean;
+        description: string;
+        ticker: string;
+        currency_name: string;
+        locale: string;
+        name: string;
+        primary_exchange: string;
+        market_cap: number;
+        delisted_utc?: string | undefined;
+        share_class_shares_outstanding?: number | null | undefined;
+    };
+    request_id: string;
+}, {
+    status: string;
+    results: {
+        type: string;
+        market: "crypto" | "stocks" | "indices" | "fx" | "otc";
+        active: boolean;
+        ticker: string;
+        currency_name: string;
+        locale: string;
+        name: string;
+        primary_exchange: string;
+        description?: string | undefined;
+        delisted_utc?: string | undefined;
+        market_cap?: number | undefined;
+        share_class_shares_outstanding?: number | null | undefined;
+    };
+    request_id: string;
+}>;
+/** Schema for Massive grouped daily response */
+export declare const MassiveGroupedDailyResponseSchema: z.ZodObject<{
+    adjusted: z.ZodBoolean;
+    queryCount: z.ZodNumber;
+    request_id: z.ZodString;
+    resultsCount: z.ZodNumber;
+    status: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        T: z.ZodString;
+        c: z.ZodNumber;
+        h: z.ZodNumber;
+        l: z.ZodNumber;
+        n: z.ZodNumber;
+        o: z.ZodNumber;
+        t: z.ZodNumber;
+        v: z.ZodNumber;
+        vw: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }, {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    adjusted: boolean;
+    results: {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }[];
+    request_id: string;
+    queryCount: number;
+    resultsCount: number;
+}, {
+    status: string;
+    adjusted: boolean;
+    results: {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }[];
+    request_id: string;
+    queryCount: number;
+    resultsCount: number;
+}>;
+/** Schema for Massive daily open close response */
+export declare const MassiveDailyOpenCloseSchema: z.ZodObject<{
+    afterHours: z.ZodOptional<z.ZodNumber>;
+    close: z.ZodNumber;
+    from: z.ZodString;
+    high: z.ZodNumber;
+    low: z.ZodNumber;
+    open: z.ZodNumber;
+    preMarket: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodString;
+    symbol: z.ZodString;
+    volume: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    close: number;
+    open: number;
+    status: string;
+    from: string;
+    low: number;
+    high: number;
+    volume: number;
+    preMarket?: number | undefined;
+    afterHours?: number | undefined;
+}, {
+    symbol: string;
+    close: number;
+    open: number;
+    status: string;
+    from: string;
+    low: number;
+    high: number;
+    volume: number;
+    preMarket?: number | undefined;
+    afterHours?: number | undefined;
+}>;
+/** Schema for a single Massive trade */
+export declare const MassiveTradeSchema: z.ZodObject<{
+    conditions: z.ZodArray<z.ZodNumber, "many">;
+    correction: z.ZodOptional<z.ZodNumber>;
+    exchange: z.ZodNumber;
+    id: z.ZodString;
+    participant_timestamp: z.ZodNumber;
+    price: z.ZodNumber;
+    sequence_number: z.ZodNumber;
+    sip_timestamp: z.ZodNumber;
+    size: z.ZodNumber;
+    tape: z.ZodOptional<z.ZodNumber>;
+    trf_id: z.ZodOptional<z.ZodNumber>;
+    trf_timestamp: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    size: number;
+    price: number;
+    exchange: number;
+    conditions: number[];
+    participant_timestamp: number;
+    sequence_number: number;
+    sip_timestamp: number;
+    correction?: number | undefined;
+    tape?: number | undefined;
+    trf_id?: number | undefined;
+    trf_timestamp?: number | undefined;
+}, {
+    id: string;
+    size: number;
+    price: number;
+    exchange: number;
+    conditions: number[];
+    participant_timestamp: number;
+    sequence_number: number;
+    sip_timestamp: number;
+    correction?: number | undefined;
+    tape?: number | undefined;
+    trf_id?: number | undefined;
+    trf_timestamp?: number | undefined;
+}>;
+/** Schema for Massive trades response */
+export declare const MassiveTradesResponseSchema: z.ZodObject<{
+    status: z.ZodLiteral<"OK">;
+    request_id: z.ZodString;
+    next_url: z.ZodOptional<z.ZodString>;
+    results: z.ZodArray<z.ZodObject<{
+        conditions: z.ZodArray<z.ZodNumber, "many">;
+        correction: z.ZodOptional<z.ZodNumber>;
+        exchange: z.ZodNumber;
+        id: z.ZodString;
+        participant_timestamp: z.ZodNumber;
+        price: z.ZodNumber;
+        sequence_number: z.ZodNumber;
+        sip_timestamp: z.ZodNumber;
+        size: z.ZodNumber;
+        tape: z.ZodOptional<z.ZodNumber>;
+        trf_id: z.ZodOptional<z.ZodNumber>;
+        trf_timestamp: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        conditions: number[];
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }, {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        conditions: number[];
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: "OK";
+    results: {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        conditions: number[];
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }[];
+    request_id: string;
+    next_url?: string | undefined;
+}, {
+    status: "OK";
+    results: {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        conditions: number[];
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }[];
+    request_id: string;
+    next_url?: string | undefined;
+}>;
+/** Schema for Massive last trade response (v3 format - returns array of trades) */
+export declare const MassiveLastTradeResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    request_id: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        conditions: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        correction: z.ZodOptional<z.ZodNumber>;
+        exchange: z.ZodNumber;
+        id: z.ZodString;
+        participant_timestamp: z.ZodNumber;
+        price: z.ZodNumber;
+        sequence_number: z.ZodNumber;
+        sip_timestamp: z.ZodNumber;
+        size: z.ZodNumber;
+        tape: z.ZodOptional<z.ZodNumber>;
+        trf_id: z.ZodOptional<z.ZodNumber>;
+        trf_timestamp: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        conditions?: number[] | undefined;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }, {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        conditions?: number[] | undefined;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    results: {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        conditions?: number[] | undefined;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }[];
+    request_id: string;
+}, {
+    status: string;
+    results: {
+        id: string;
+        size: number;
+        price: number;
+        exchange: number;
+        participant_timestamp: number;
+        sequence_number: number;
+        sip_timestamp: number;
+        conditions?: number[] | undefined;
+        correction?: number | undefined;
+        tape?: number | undefined;
+        trf_id?: number | undefined;
+        trf_timestamp?: number | undefined;
+    }[];
+    request_id: string;
+}>;
+/** Schema for Massive aggregates (bars) response */
+export declare const MassiveAggregatesResponseSchema: z.ZodObject<{
+    adjusted: z.ZodOptional<z.ZodBoolean>;
+    next_url: z.ZodOptional<z.ZodString>;
+    queryCount: z.ZodOptional<z.ZodNumber>;
+    request_id: z.ZodString;
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        T: z.ZodString;
+        c: z.ZodNumber;
+        h: z.ZodNumber;
+        l: z.ZodNumber;
+        n: z.ZodNumber;
+        o: z.ZodNumber;
+        t: z.ZodNumber;
+        v: z.ZodNumber;
+        vw: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }, {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }>, "many">>;
+    resultsCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodString;
+    ticker: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    request_id: string;
+    ticker?: string | undefined;
+    adjusted?: boolean | undefined;
+    results?: {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }[] | undefined;
+    queryCount?: number | undefined;
+    resultsCount?: number | undefined;
+    next_url?: string | undefined;
+}, {
+    status: string;
+    request_id: string;
+    ticker?: string | undefined;
+    adjusted?: boolean | undefined;
+    results?: {
+        t: number;
+        T: string;
+        o: number;
+        h: number;
+        l: number;
+        c: number;
+        v: number;
+        vw: number;
+        n: number;
+    }[] | undefined;
+    queryCount?: number | undefined;
+    resultsCount?: number | undefined;
+    next_url?: string | undefined;
+}>;
+/** Schema for Massive error response */
+export declare const MassiveErrorResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    request_id: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    message: string;
+    request_id: string;
+}, {
+    status: string;
+    message: string;
+    request_id: string;
+}>;
+//# sourceMappingURL=massive-schemas.d.ts.map

package/dist/types/schemas/massive-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"massive-schemas.d.ts","sourceRoot":"","sources":["../../../src/schemas/massive-schemas.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUpC,CAAC;AAIH,8CAA8C;AAC9C,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAalC,CAAC;AAEH,gEAAgE;AAChE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI7C,CAAC;AAIH,gDAAgD;AAChD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO5C,CAAC;AAIH,mDAAmD;AACnD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWtC,CAAC;AAIH,wCAAwC;AACxC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa7B,CAAC;AAEH,yCAAyC;AACzC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAC;AAIH,mFAAmF;AACnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBzC,CAAC;AAIH,oDAAoD;AACpD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS1C,CAAC;AAIH,wCAAwC;AACxC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAIrC,CAAC"}

package/dist/types/schemas/validate-response.d.ts

@@ -0,0 +1,88 @@
+/**
+ * API response validation utility.
+ * Parses API responses through Zod schemas to catch breaking API changes early.
+ */
+import { z } from "zod";
+/**
+ * Result of a validation attempt.
+ * On success, contains the parsed data.
+ * On failure, contains the original data and validation errors.
+ */
+export interface ValidationResult<T> {
+    /** Whether validation succeeded */
+    success: boolean;
+    /** Parsed and validated data (only present on success) */
+    data: T;
+    /** Validation errors (only present on failure) */
+    errors?: z.ZodIssue[];
+}
+/**
+ * Options for response validation behavior
+ */
+export interface ValidateResponseOptions {
+    /**
+     * Whether to throw on validation failure.
+     * When false (default), logs a warning and returns the original data.
+     * When true, throws a ValidationResponseError.
+     */
+    strict?: boolean;
+    /**
+     * Label for logging purposes (e.g., "AlpacaAPI.getAccount")
+     */
+    label?: string;
+}
+/**
+ * Error thrown when strict validation fails
+ */
+export declare class ValidationResponseError extends Error {
+    /** The Zod validation issues */
+    readonly issues: z.ZodIssue[];
+    /** The original data that failed validation */
+    readonly originalData: unknown;
+    constructor(message: string, issues: z.ZodIssue[], originalData: unknown);
+}
+/**
+ * Validates an API response against a Zod schema.
+ *
+ * In non-strict mode (default), validation failures are logged as warnings
+ * and the original data is returned. This allows the application to continue
+ * operating even if the API response shape changes slightly, while still
+ * alerting developers to the discrepancy.
+ *
+ * In strict mode, validation failures throw a ValidationResponseError.
+ *
+ * @param data - The API response data to validate
+ * @param schema - The Zod schema to validate against
+ * @param options - Validation options (strict mode, label)
+ * @returns The validated (and potentially transformed) data
+ * @throws ValidationResponseError if strict mode is enabled and validation fails
+ *
+ * @example
+ * ```typescript
+ * const account = await fetchAccountDetails(auth);
+ * const validated = validateResponse(account, AlpacaAccountDetailsSchema, {
+ *   label: 'AlpacaAPI.getAccount',
+ * });
+ * ```
+ */
+export declare function validateResponse<T>(data: unknown, schema: z.ZodType<T>, options?: ValidateResponseOptions): T;
+/**
+ * Safely validates an API response, returning a result object instead of throwing.
+ * Useful when you need to inspect validation results without try/catch.
+ *
+ * @param data - The API response data to validate
+ * @param schema - The Zod schema to validate against
+ * @returns A ValidationResult object with success status, data, and errors
+ *
+ * @example
+ * ```typescript
+ * const result = safeValidateResponse(data, AlpacaBarSchema);
+ * if (result.success) {
+ *   // result.data is typed and validated
+ * } else {
+ *   // result.errors contains Zod issues
+ * }
+ * ```
+ */
+export declare function safeValidateResponse<T>(data: unknown, schema: z.ZodType<T>): ValidationResult<T>;
+//# sourceMappingURL=validate-response.d.ts.map

package/dist/types/schemas/validate-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-response.d.ts","sourceRoot":"","sources":["../../../src/schemas/validate-response.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAY,MAAM,KAAK,CAAC;AAGlC;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,IAAI,EAAE,CAAC,CAAC;IACR,kDAAkD;IAClD,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,gCAAgC;IAChC,SAAgB,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;IACrC,+CAA+C;IAC/C,SAAgB,YAAY,EAAE,OAAO,CAAC;gBAE1B,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE,YAAY,EAAE,OAAO;CAMzE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,uBAA4B,GACpC,CAAC,CAoCH;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GACnB,gBAAgB,CAAC,CAAC,CAAC,CAerB"}

package/dist/types/trading-policy/defaults/default-trading-policy.d.ts

@@ -0,0 +1,29 @@
+import { type EffectiveTradingPolicy } from "../schemas/effective-policy.schema";
+/**
+ * Default trading policy used as the baseline when no user-customized policy
+ * exists. Calibrated for short-horizon day trading / HFT-microstructuring /
+ * scalping (intraday holds, 5-min-bar-sized stops, fast cooldowns) per the
+ * 2026-05-10 audit, replacing the previous swing-trading calibration.
+ *
+ * All nested preference sub-objects are passed as empty objects so Zod applies
+ * their field-level defaults (which are themselves tuned for scalping in their
+ * respective schema files).
+ *
+ * Key choices:
+ * - Advisory-only autonomy (no autonomous execution)
+ * - Real-time trading enabled
+ * - Equities, ETFs, crypto, options, futures, and forex enabled
+ * - No shorting or margin (user must opt-in)
+ * - All protective overlays disabled (user must opt-in)
+ * - No LLM providers pre-configured
+ * - Tighter per-trade allocation (2% vs 5%) and concurrency (8 positions vs 20)
+ *   reflecting the increased turnover and decreased per-position conviction
+ *   characteristic of scalping
+ * - Faster equity wash-trade cooldown (5s vs 30s) — FINRA Rule 5210 governs
+ *   opposing-side wash trades; same-side intraday re-entry can be much faster
+ * - Tighter daily-loss circuit breaker (2% vs 3%) reflecting that scalping
+ *   strategies should fail fast rather than burn the day's risk budget on
+ *   one bad regime
+ */
+export declare const DEFAULT_TRADING_POLICY: EffectiveTradingPolicy;
+//# sourceMappingURL=default-trading-policy.d.ts.map

package/dist/types/trading-policy/defaults/default-trading-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-trading-policy.d.ts","sourceRoot":"","sources":["../../../../src/trading-policy/defaults/default-trading-policy.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,oCAAoC,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,sBAAsB,EAAE,sBA+DjC,CAAC"}