laplace-api 3.1.0 → 4.0.0

package/src/client/funds.ts

@@ -0,0 +1,139 @@
+import { Client } from "./client";
+import { Region } from "./collections";
+import { AssetType } from "./stocks";
+
+export enum FundType {
+  STOCK_UMBRELLA_FUND = "STOCK_UMBRELLA_FUND",
+  VARIABLE_UMBRELLA_FUND = "VARIABLE_UMBRELLA_FUND",
+  PARTICIPATION_UMBRELLA_FUND = "PARTICIPATION_UMBRELLA_FUND",
+  FLEXIBLE_UMBRELLA_FUND = "FLEXIBLE_UMBRELLA_FUND",
+  FUND_BASKET_UMBRELLA_FUND = "FUND_BASKET_UMBRELLA_FUND",
+  MONEY_MARKET_UMBRELLA_FUND = "MONEY_MARKET_UMBRELLA_FUND",
+  PRECIOUS_METALS_UMBRELLA_FUND = "PRECIOUS_METALS_UMBRELLA_FUND",
+  DEBT_INSTRUMENTS_UMBRELLA_FUND = "DEBT_INSTRUMENTS_UMBRELLA_FUND",
+  MIXED_UMBRELLA_FUND = "MIXED_UMBRELLA_FUND",
+  UNKNOWN_FUND_TYPE = "UNKNOWN_FUND_TYPE",
+}
+
+export interface Fund {
+  assetType: AssetType;
+  name: string;
+  symbol: string;
+  active: boolean;
+  managementFee: number;
+  riskLevel: number;
+  fundType: FundType;
+  ownerSymbol: string;
+}
+
+export interface FundStats {
+  yearBeta: number;
+  yearStdev: number;
+  ytdReturn: number;
+  yearMomentum: number;
+  yearlyReturn: number;
+  monthlyReturn: number;
+  fiveYearReturn: number;
+  sixMonthReturn: number;
+  threeYearReturn: number;
+  threeMonthReturn: number;
+}
+
+export enum FundContentType {
+  BIST_STOCK = "BIST_STOCK",
+  OTHER_STOCK = "OTHER_STOCK",
+  UNKNOWN = "UNKNOWN",
+}
+
+export enum FundAssetCategory {
+  OTHER = "OTHER",
+  EQUITY = "EQUITY",
+  LIQUID_DEPOSIT = "LIQUID_DEPOSIT",
+  FUTURES_CASH_COLLATERAL = "FUTURES_CASH_COLLATERAL",
+  INVESTMENT_FUNDS = "INVESTMENT_FUNDS",
+  PARTICIPATION_ACCOUNT = "PARTICIPATION_ACCOUNT",
+  PRECIOUS_METALS = "PRECIOUS_METALS",
+  CORPORATE_BOND = "CORPORATE_BOND",
+  CURRENCY = "CURRENCY",
+  PUBLIC_EXTERNAL_DEBT_SECURITIES = "PUBLIC_EXTERNAL_DEBT_SECURITIES",
+  PRIVATE_SECTOR_EXTERNAL_DEBT_SECURITIES = "PRIVATE_SECTOR_EXTERNAL_DEBT_SECURITIES",
+  PUBLIC_LEASE_CERTIFICATES = "PUBLIC_LEASE_CERTIFICATES",
+  PRIVATE_SECTOR_LEASE_CERTIFICATES = "PRIVATE_SECTOR_LEASE_CERTIFICATES",
+  FOREIGN_EXCHANGE_TRADED_FUNDS = "FOREIGN_EXCHANGE_TRADED_FUNDS",
+  PUBLIC_LEASE_CERTIFICATES_CURRENCY = "PUBLIC_LEASE_CERTIFICATES_CURRENCY",
+  GOVERNMENT_BOND = "GOVERNMENT_BOND",
+  PRIVATE_SECTOR_LEASE_CERTIFICATES_CURRENCY = "PRIVATE_SECTOR_LEASE_CERTIFICATES_CURRENCY",
+  UNKNOWN = "UNKNOWN",
+}
+
+export interface FundAsset {
+  type: FundContentType;
+  symbol: string;
+  wholePercentage: number;
+  categoryPercentage: number;
+}
+
+export interface FundDistribution {
+  categories: FundCategoryDistribution[];
+}
+
+export interface FundCategoryDistribution {
+  category: FundAssetCategory;
+  percentage: number;
+  assets?: FundAsset[];
+}
+
+export enum HistoricalFundPricePeriod {
+  OneWeek = "1H",
+  OneMonth = "1A",
+  ThreeMonth = "3A",
+  OneYear = "1Y",
+  ThreeYear = "3Y",
+  FiveYear = "5Y",
+}
+
+export interface FundHistoricalPrice {
+  aum: number;
+  date: string;
+  price: number;
+  shareCount: number;
+  investorCount: number;
+}
+
+export class FundsClient extends Client {
+  async getFunds(region: Region, page: number, pageSize: number) {
+    return this.sendRequest<Fund[]>({
+      method: "GET",
+      url: `/api/v1/fund`,
+      params: { region, page, pageSize },
+    });
+  }
+
+  async getFundStats(symbol: string, region: Region) {
+    return this.sendRequest<FundStats>({
+      method: "GET",
+      url: `/api/v1/fund/stats`,
+      params: { symbol, region },
+    });
+  }
+
+  async getFundDistribution(symbol: string, region: Region) {
+    return this.sendRequest<FundDistribution>({
+      method: "GET",
+      url: `/api/v1/fund/distribution`,
+      params: { symbol, region },
+    });
+  }
+
+  async getHistoricalFundPrices(
+    symbol: string,
+    region: Region,
+    period: HistoricalFundPricePeriod
+  ) {
+    return this.sendRequest<FundHistoricalPrice[]>({
+      method: "GET",
+      url: `/api/v1/fund/price`,
+      params: { symbol, region, period },
+    });
+  }
+}

package/src/client/key-insights.ts

@@ -0,0 +1,17 @@
+import { Client } from "./client";
+import { Region } from "./collections";
+
+export interface KeyInsight {
+  symbol: string;
+  insight: string;
+}
+
+export class KeyInsightClient extends Client {
+  async getKeyInsights(symbol: string, region: Region) {
+    return this.sendRequest<KeyInsight>({
+      method: "GET",
+      url: "/api/v1/key-insight",
+      params: { symbol, region },
+    });
+  }
+}

package/src/client/live-price.ts

@@ -24,6 +24,21 @@ export interface USStockLiveData {
   ap: number; // AskPrice
 }
 
+export enum AccessorType {
+  User = "user"
+}
+
+interface UpdateUserDetailsParams {
+  externalUserID: string;
+  firstName?: string;
+  lastName?: string;
+  address?: string;
+  city?: string;
+  countryCode?: string;
+  accessorType?: AccessorType; 
+  active: boolean;
+}
+
 function getSSELivePrice<T>(
   client: Client,
   symbols: string[],
@@ -59,6 +74,16 @@ export class LivePriceClient extends Client {
     return response.url;
   }
 
+  async updateUserDetails(params: UpdateUserDetailsParams): Promise<void> {
+    const url = new URL(`${this["baseUrl"]}/api/v1/ws/user`);
+
+    await this.sendRequest<void>({
+      method: "PUT",
+      url: url.toString(),
+      data: params,
+    });
+  }
+
   getLivePriceForBIST(
     symbols: string[], 
     region: Region,

package/src/client/stocks.ts

@@ -64,7 +64,7 @@ export interface StockDetail extends Stock {
   shortDescription: string;
   localizedShortDescription: LocaleString;
   region: string;
-  markets: Market[];
+  markets?: Market[];
 }
 
 export enum Market {
@@ -102,8 +102,10 @@ export interface StockRestriction {
   id: number;
   title: string;
   description: string;
+  symbol?: string;
   startDate: string;
   endDate: string;
+  market?: string;
 }
 
 export interface TickRule {
@@ -111,7 +113,7 @@ export interface TickRule {
   additionalPrice: number;
   lowerPriceLimit: number;
   upperPriceLimit: number;
-  rules: TickSizeRule[];
+  rules: TickSizeRule[] | null;
 }
 
 export interface TickSizeRule {
@@ -188,6 +190,14 @@ export class StockClient extends Client {
     });
   }
 
+  async getAllStockRestrictions(region: Region): Promise<StockRestriction[]> {
+    return this.sendRequest<StockRestriction[]>({
+      method: 'GET',
+      url: '/api/v1/stock/restrictions/all',
+      params: { region },
+    });
+  }
+
   async getTickRules(symbol: string, region: Region): Promise<TickRule> {
     return this.sendRequest<TickRule>({
       method: 'GET',

package/src/test/broker.test.ts

@@ -3,13 +3,10 @@ import { Region } from "../client/collections";
 import { LaplaceConfiguration } from "../utilities/configuration";
 import "./client_test_suite";
 import {
-  BaseBrokerStats,
   BrokerClient,
   BrokerSort,
+  SortDirection,
   BrokerStats,
-  BrokerStockStats,
-  StockBrokerStats,
-  StockOverallStats,
 } from "../client/broker";
 
 describe("BrokerClient", () => {
@@ -35,9 +32,10 @@ describe("BrokerClient", () => {
   test("getMarketBrokers returns valid and fully typed data", async () => {
     const response = await brokerClient.getMarketBrokers(
       Region.Tr,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
       "2025-05-27",
       "2025-05-28",
-      BrokerSort.Volume,
       0,
       5
     );
@@ -46,7 +44,7 @@ describe("BrokerClient", () => {
     expect(typeof response.recordCount).toBe("number");
 
     const stats = response.totalStats;
-    expect(stats).toMatchObject<BaseBrokerStats>({
+    expect(stats).toMatchObject<BrokerStats>({
       totalBuyAmount: expect.any(Number),
       totalSellAmount: expect.any(Number),
       netAmount: expect.any(Number),
@@ -68,44 +66,48 @@ describe("BrokerClient", () => {
         totalSellVolume: expect.any(Number),
         totalVolume: expect.any(Number),
         totalAmount: expect.any(Number),
-        broker: {
+      });
+
+      if (item.broker) {
+        expect(item.broker).toMatchObject({
           id: expect.any(Number),
           symbol: expect.any(String),
           name: expect.any(String),
           longName: expect.any(String),
           logo: expect.any(String),
-        },
-      });
+        });
+      }
     }
   });
 
-  test("getTopMarketBrokers returns fully typed top and rest stats", async () => {
-    const response = await brokerClient.getTopMarketBrokers(
+  test("getMarketStocks returns valid stock data", async () => {
+    const response = await brokerClient.getMarketStocks(
       region,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
       fromDate,
       toDate,
-      BrokerSort.Volume
+      0,
+      5
     );
 
     expect(response).toBeDefined();
+    expect(typeof response.recordCount).toBe("number");
 
-    const statsList = [response.topStats, response.restStats];
-    for (const stats of statsList) {
-      expect(stats).toMatchObject<BaseBrokerStats>({
-        totalBuyAmount: expect.any(Number),
-        totalSellAmount: expect.any(Number),
-        netAmount: expect.any(Number),
-        totalBuyVolume: expect.any(Number),
-        totalSellVolume: expect.any(Number),
-        totalVolume: expect.any(Number),
-        totalAmount: expect.any(Number),
-      });
-    }
+    const stats = response.totalStats;
+    expect(stats).toMatchObject<BrokerStats>({
+      totalBuyAmount: expect.any(Number),
+      totalSellAmount: expect.any(Number),
+      netAmount: expect.any(Number),
+      totalBuyVolume: expect.any(Number),
+      totalSellVolume: expect.any(Number),
+      totalVolume: expect.any(Number),
+      totalAmount: expect.any(Number),
+    });
 
-    expect(Array.isArray(response.topItems)).toBe(true);
-    expect(response.topItems.length).toBeGreaterThan(0);
+    expect(Array.isArray(response.items)).toBe(true);
 
-    for (const item of response.topItems) {
+    for (const item of response.items) {
       expect(item).toMatchObject<BrokerStats>({
         totalBuyAmount: expect.any(Number),
         totalSellAmount: expect.any(Number),
@@ -114,24 +116,28 @@ describe("BrokerClient", () => {
         totalSellVolume: expect.any(Number),
         totalVolume: expect.any(Number),
         totalAmount: expect.any(Number),
-        broker: {
-          id: expect.any(Number),
+      });
+
+      if (item.stock) {
+        expect(item.stock).toMatchObject({
+          id: expect.any(String),
           symbol: expect.any(String),
           name: expect.any(String),
-          longName: expect.any(String),
-          logo: expect.any(String),
-        },
-      });
+          assetType: expect.any(String),
+          assetClass: expect.any(String),
+        });
+      }
     }
   });
 
-  test("getStockBrokers returns full broker stats with averageCost", async () => {
-    const response = await brokerClient.getStockBrokers(
+  test("getBrokersByStock returns brokers for specific stock", async () => {
+    const response = await brokerClient.getBrokersByStock(
+      "TUPRS",
       region,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
       fromDate,
       toDate,
-      BrokerSort.Volume,
-      "TUPRS",
       0,
       5
     );
@@ -139,7 +145,8 @@ describe("BrokerClient", () => {
     expect(response).toBeDefined();
     expect(typeof response.recordCount).toBe("number");
 
-    expect(response.totalStats).toMatchObject<StockOverallStats>({
+    const stats = response.totalStats;
+    expect(stats).toMatchObject<BrokerStats>({
       totalBuyAmount: expect.any(Number),
       totalSellAmount: expect.any(Number),
       netAmount: expect.any(Number),
@@ -147,43 +154,12 @@ describe("BrokerClient", () => {
       totalSellVolume: expect.any(Number),
       totalVolume: expect.any(Number),
       totalAmount: expect.any(Number),
-      averageCost: expect.any(Number),
     });
 
-    for (const item of response.items) {
-      expect(item).toMatchObject<StockBrokerStats>({
-        averageCost: expect.any(Number),
-        totalBuyAmount: expect.any(Number),
-        totalSellAmount: expect.any(Number),
-        netAmount: expect.any(Number),
-        totalBuyVolume: expect.any(Number),
-        totalSellVolume: expect.any(Number),
-        totalVolume: expect.any(Number),
-        totalAmount: expect.any(Number),
-        broker: {
-          id: expect.any(Number),
-          symbol: expect.any(String),
-          name: expect.any(String),
-          longName: expect.any(String),
-          logo: expect.any(String),
-        },
-      });
-    }
-  });
-
-  test("getTopStockBrokers returns fully typed top & rest stats with averageCost", async () => {
-    const response = await brokerClient.getTopStockBrokers(
-      region,
-      fromDate,
-      toDate,
-      BrokerSort.Volume,
-      "TUPRS"
-    );
-
-    expect(response).toBeDefined();
+    expect(Array.isArray(response.items)).toBe(true);
 
-    for (const stats of [response.topStats, response.restStats]) {
-      expect(stats).toMatchObject<StockOverallStats>({
+    for (const item of response.items) {
+      expect(item).toMatchObject<BrokerStats>({
         totalBuyAmount: expect.any(Number),
         totalSellAmount: expect.any(Number),
         netAmount: expect.any(Number),
@@ -191,44 +167,54 @@ describe("BrokerClient", () => {
         totalSellVolume: expect.any(Number),
         totalVolume: expect.any(Number),
         totalAmount: expect.any(Number),
-        averageCost: expect.any(Number),
       });
-    }
 
-    for (const item of response.topItems) {
-      expect(item).toMatchObject<StockBrokerStats>({
-        averageCost: expect.any(Number),
-        totalBuyAmount: expect.any(Number),
-        totalSellAmount: expect.any(Number),
-        netAmount: expect.any(Number),
-        totalBuyVolume: expect.any(Number),
-        totalSellVolume: expect.any(Number),
-        totalVolume: expect.any(Number),
-        totalAmount: expect.any(Number),
-        broker: {
+      if (item.broker) {
+        expect(item.broker).toMatchObject({
           id: expect.any(Number),
           symbol: expect.any(String),
           name: expect.any(String),
           longName: expect.any(String),
           logo: expect.any(String),
-        },
-      });
+        });
+      }
+
+      if ("averageCost" in item) {
+        expect(item.averageCost).toEqual(expect.any(Number));
+      }
     }
   });
 
-  test("getTopBrokersForBroker returns top brokers without averageCost", async () => {
-    const response = await brokerClient.getTopStocksForBroker(
+  test("getStocksByBroker returns stocks for specific broker", async () => {
+    const response = await brokerClient.getStocksByBroker(
+      "BIYKR",
       region,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
       fromDate,
       toDate,
-      BrokerSort.Volume,
-      "BIYKR"
+      0,
+      5
     );
 
     expect(response).toBeDefined();
+    expect(typeof response.recordCount).toBe("number");
 
-    for (const stats of [response.topStats, response.restStats]) {
-      expect(stats).toMatchObject<BaseBrokerStats>({
+    const stats = response.totalStats;
+    expect(stats).toMatchObject<BrokerStats>({
+      totalBuyAmount: expect.any(Number),
+      totalSellAmount: expect.any(Number),
+      netAmount: expect.any(Number),
+      totalBuyVolume: expect.any(Number),
+      totalSellVolume: expect.any(Number),
+      totalVolume: expect.any(Number),
+      totalAmount: expect.any(Number),
+    });
+
+    expect(Array.isArray(response.items)).toBe(true);
+
+    for (const item of response.items) {
+      expect(item).toMatchObject<BrokerStats>({
         totalBuyAmount: expect.any(Number),
         totalSellAmount: expect.any(Number),
         netAmount: expect.any(Number),
@@ -237,26 +223,16 @@ describe("BrokerClient", () => {
         totalVolume: expect.any(Number),
         totalAmount: expect.any(Number),
       });
-    }
 
-    for (const item of response.topItems) {
-      expect(item).toMatchObject<BrokerStockStats>({
-        totalBuyAmount: expect.any(Number),
-        totalSellAmount: expect.any(Number),
-        netAmount: expect.any(Number),
-        totalBuyVolume: expect.any(Number),
-        totalSellVolume: expect.any(Number),
-        totalVolume: expect.any(Number),
-        totalAmount: expect.any(Number),
-        stock: {
+      if (item.stock) {
+        expect(item.stock).toMatchObject({
           id: expect.any(String),
           symbol: expect.any(String),
           name: expect.any(String),
           assetType: expect.any(String),
           assetClass: expect.any(String),
-          region: expect.any(String),
-        },
-      });
+        });
+      }
     }
   });
 });

package/src/test/capital_increase.test.ts

@@ -1,15 +1,16 @@
-import { Logger } from 'winston';
-import { LaplaceConfiguration } from '../utilities/configuration';
-import { CapitalIncreaseClient } from '../client/capital_increase';
-import { Region } from '../client/collections';
-import './client_test_suite';
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import {
+  CapitalIncrease,
+  CapitalIncreaseClient,
+} from "../client/capital_increase";
+import "./client_test_suite";
+import { Region } from "../client/collections";
 
-
-describe('Capital Increase', () => {
+describe("Capital Increase", () => {
   let client: CapitalIncreaseClient;
 
   beforeAll(() => {
-    // Assuming global.testSuite is set up as in the previous example
     const config = (global as any).testSuite.config as LaplaceConfiguration;
     const logger: Logger = {
       info: jest.fn(),
@@ -21,16 +22,119 @@ describe('Capital Increase', () => {
     client = new CapitalIncreaseClient(config, logger);
   });
 
-  test('GetAllCapitalIncreases', async () => {
-    await client.getAllCapitalIncreases(1, 10, Region.Tr, );
-  });
+  test("GetAllCapitalIncreases", async () => {
+    const resp = await client.getAllCapitalIncreases(1, 10, Region.Tr);
+
+    expect(resp).toBeDefined();
+    expect(typeof resp.recordCount).toBe("number");
+    expect(Array.isArray(resp.items)).toBe(true);
 
-  test('GetCapitalIncreasesForInstrument', async () => {
-    await client.getCapitalIncreasesForInstrument("TUPRS", 1, 10, Region.Tr);
+    if (resp.items.length > 0) {
+      const firstItem = resp.items[0];
+      validateCapitalIncrease(firstItem);
+    }
   });
 
-  test('GetActiveRightsForInstrument', async () => {
-     await client.getActiveRightsForInstrument("TUPRS", "2024-01-01", Region.Tr);
+  test("GetCapitalIncreasesForInstrument", async () => {
+    const resp = await client.getCapitalIncreasesForInstrument(
+      "TUPRS",
+      1,
+      10,
+      Region.Tr
+    );
+
+    expect(resp).toBeDefined();
+    expect(typeof resp.recordCount).toBe("number");
+    expect(Array.isArray(resp.items)).toBe(true);
+
+    if (resp.items.length > 0) {
+      const firstItem = resp.items[0];
+      validateCapitalIncrease(firstItem);
+      expect(firstItem.symbol).toBe("TUPRS");
+    }
   });
 
+  test("GetActiveRightsForInstrument", async () => {
+    const resp = await client.getActiveRightsForInstrument(
+      "TUPRS",
+      "2024-01-01",
+      Region.Tr
+    );
+
+    expect(Array.isArray(resp)).toBe(true);
+
+    if (resp.length > 0) {
+      const firstItem = resp[0];
+      validateCapitalIncrease(firstItem);
+      expect(firstItem.symbol).toBe("TUPRS");
+    }
+  });
 });
+
+function validateCapitalIncrease(item: CapitalIncrease) {
+  expect(typeof item.id).toBe("number");
+  expect(typeof item.boardDecisionDate).toBe("string");
+  expect(typeof item.registeredCapitalCeiling).toBe("string");
+  expect(typeof item.currentCapital).toBe("string");
+  expect(typeof item.targetCapital).toBe("string");
+  expect(Array.isArray(item.types)).toBe(true);
+  
+  if (item.spkApplicationResult !== null) {
+    expect(typeof item.spkApplicationResult).toBe("string");
+  }
+  
+  if (item.spkApplicationDate !== null) {
+    expect(typeof item.spkApplicationDate).toBe("string");
+  }
+  
+  if (item.spkApprovalDate !== null) {
+    expect(typeof item.spkApprovalDate).toBe("string");
+  }
+  
+  if (item.paymentDate !== null) {
+    expect(typeof item.paymentDate).toBe("string");
+  }
+  
+  if (item.registrationDate !== null) {
+    expect(typeof item.registrationDate).toBe("string");
+  }
+  
+  expect(typeof item.specifiedCurrency).toBe("string");
+  expect(typeof item.symbol).toBe("string");
+  expect(Array.isArray(item.relatedDisclosureIds)).toBe(true);
+  expect(typeof item.rightsRate).toBe("string");
+  expect(typeof item.rightsPrice).toBe("string");
+  expect(typeof item.rightsTotalAmount).toBe("string");
+  
+  if (item.rightsStartDate !== null) {
+    expect(typeof item.rightsStartDate).toBe("string");
+  }
+  
+  if (item.rightsEndDate !== null) {
+    expect(typeof item.rightsEndDate).toBe("string");
+  }
+  
+  if (item.rightsLastSellDate !== null) {
+    expect(typeof item.rightsLastSellDate).toBe("string");
+  }
+  
+  expect(typeof item.bonusRate).toBe("string");
+  expect(typeof item.bonusTotalAmount).toBe("string");
+  
+  if (item.bonusStartDate !== null) {
+    expect(typeof item.bonusStartDate).toBe("string");
+  }
+  
+  expect(typeof item.bonusDividendRate).toBe("string");
+  expect(typeof item.bonusDividendTotalAmount).toBe("string");
+  expect(typeof item.externalCapitalIncreaseAmount).toBe("string");
+  expect(typeof item.externalCapitalIncreaseRate).toBe("string");
+  
+  item.types.forEach(type => {
+    expect(typeof type).toBe("string");
+  });
+  
+  item.relatedDisclosureIds.forEach(id => {
+    expect(typeof id).toBe("number");
+  });
+}