openfigi-sdk 1.0.3

package/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,239 @@
+# openfigi-sdk
+
+A modern, type-safe TypeScript SDK for the [OpenFIGI API](https://www.openfigi.com/api) - the free and open standard for financial instrument identification.
+
+[![CI](https://github.com/viktorlarsson/openfigi/actions/workflows/ci.yml/badge.svg)](https://github.com/viktorlarsson/openfigi/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/openfigi-sdk.svg)](https://www.npmjs.com/package/openfigi-sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> **⚠️ Community Project Disclaimer**
+> This is an **unofficial, community-maintained** TypeScript SDK for OpenFIGI. It is **not affiliated with or endorsed by OpenFIGI or Bloomberg**. This library is developed and maintained by the open-source community. For official support, please refer to the [OpenFIGI official documentation](https://www.openfigi.com/api).
+
+## Features
+
+- **Type-safe** - Full TypeScript support with comprehensive type definitions
+- **Modern** - Built with latest technologies (Bun, Vitest, Biome, tsup)
+- **Validated** - Runtime validation using Zod schemas
+- **Resilient** - Built-in retry logic with exponential backoff
+- **Rate Limiting** - Automatic rate limit handling
+- **Developer Friendly** - Simple API with convenience methods
+- **Well Tested** - Comprehensive test coverage
+- **Tree-shakeable** - Optimized bundle size with ESM/CJS support
+
+## Installation
+
+```bash
+# Using bun
+bun add openfigi-sdk
+
+# Using npm
+npm install openfigi-sdk
+
+# Using pnpm
+pnpm add openfigi-sdk
+```
+
+## Quick Start
+
+```typescript
+import { searchByISIN, searchByCUSIP, searchByTicker, searchBySEDOL, searchByBloombergId, createClient } from 'openfigi-sdk'
+
+// Use standalone functions (no API key required for public access)
+const response = await searchByISIN('US0378331005')
+console.log(response.data)
+
+// Search by CUSIP
+await searchByCUSIP('037833100')
+
+// Search by ticker symbol
+await searchByTicker('AAPL', 'US')
+
+// Search by SEDOL
+await searchBySEDOL('2046251')
+
+// Search by Bloomberg ID
+await searchByBloombergId('BBG000B9XRY4')
+
+// Or create a client with custom configuration (e.g., API key for higher rate limits)
+const client = createClient({
+  apiKey: 'your-api-key-here',
+  timeout: 60000
+})
+
+const result = await client.searchByISIN('US0378331005')
+```
+
+## API Reference
+
+### Client Configuration
+
+```typescript
+interface ClientConfig {
+  apiKey?: string        // OpenFIGI API key for higher rate limits
+  baseUrl?: string       // API base URL (default: https://api.openfigi.com)
+  timeout?: number       // Request timeout in ms (default: 30000)
+  retryLimit?: number    // Number of retry attempts (default: 3)
+  retryDelay?: number    // Initial retry delay in ms (default: 1000)
+  userAgent?: string     // Custom user agent
+}
+```
+
+### Batch Mapping
+
+```typescript
+import { mapping, createClient } from 'openfigi-sdk'
+
+// Map multiple identifiers in a single request (max 100)
+const requests = [
+  { idType: 'ID_ISIN', idValue: 'US0378331005' },
+  { idType: 'ID_CUSIP', idValue: '037833100' },
+  { idType: 'ID_SEDOL', idValue: '2046251' }
+]
+
+// Using standalone function
+const responses = await mapping(requests)
+
+// Or with custom client
+const client = createClient({ apiKey: 'your-key' })
+const responses = await client.mapping(requests)
+
+responses.forEach((response, index) => {
+  if (response.data) {
+    console.log(`Request ${index}:`, response.data)
+  } else if (response.error) {
+    console.error(`Request ${index} failed:`, response.error)
+  }
+})
+```
+
+### Advanced Search Options
+
+```typescript
+import { searchByISIN, mappingSingle } from 'openfigi-sdk'
+
+// Search with additional filters
+const response = await searchByISIN('US0378331005', {
+  exchCode: 'US',
+  currency: 'USD',
+  marketSecDes: 'Equity',
+  includeUnlistedEquities: false
+})
+
+// Custom mapping request
+const response = await mappingSingle({
+  idType: 'ID_BB_GLOBAL',
+  idValue: 'BBG000B9XRY4',
+  currency: 'USD',
+  micCode: 'XNGS'
+})
+```
+
+### Error Handling
+
+```typescript
+import { searchByISIN, OpenFigiError, RateLimitError, ValidationError } from 'openfigi-sdk'
+
+try {
+  const response = await searchByISIN('invalid-isin')
+} catch (error) {
+  if (error instanceof RateLimitError) {
+    console.log('Rate limited. Retry after:', error.retryAfter)
+  } else if (error instanceof ValidationError) {
+    console.log('Invalid request:', error.message)
+  } else if (error instanceof OpenFigiError) {
+    console.log('API error:', error.message, error.statusCode)
+  }
+}
+```
+
+### Rate Limit Information
+
+```typescript
+import { searchByISIN, getRateLimitInfo } from 'openfigi-sdk'
+
+// Check current rate limit status after any request
+const response = await searchByISIN('US0378331005')
+const rateLimitInfo = getRateLimitInfo()
+
+if (rateLimitInfo) {
+  console.log('Rate limit:', rateLimitInfo.limit)
+  console.log('Remaining:', rateLimitInfo.remaining)
+  console.log('Reset time:', rateLimitInfo.reset)
+}
+```
+
+## Supported Identifier Types
+
+- `ID_ISIN` - International Securities Identification Number
+- `ID_CUSIP` - Committee on Uniform Securities Identification Procedures
+- `ID_SEDOL` - Stock Exchange Daily Official List
+- `ID_BB_GLOBAL` - Bloomberg Global Identifier
+- `ID_EXCH_SYMBOL` - Exchange symbol/ticker
+- `ID_BB_UNIQUE` - Bloomberg Unique Identifier
+- `ID_WERTPAPIER` - Wertpapierkennnummer (German securities code)
+- And many more...
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run tests
+bun test
+
+# Run tests with coverage
+bun run test:coverage
+
+# Build the library
+bun run build
+
+# Lint code
+bun run lint
+
+# Type check
+bun run typecheck
+
+# Generate documentation
+bun run docs
+```
+
+## API Rate Limits
+
+- **Without API Key**: Lower rate limit for public access
+- **With API Key**: Higher rate limit for authenticated requests
+
+To get an API key, sign up at [OpenFIGI.com](https://www.openfigi.com/).
+
+## Contributing
+
+This is a **community-driven project** and contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+**Note**: This library is maintained by the community and is not affiliated with OpenFIGI or Bloomberg. For official API support, please contact OpenFIGI directly.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Links
+
+- [OpenFIGI API Documentation](https://www.openfigi.com/api/documentation)
+- [OpenFIGI Website](https://www.openfigi.com/)
+- [GitHub Repository](https://github.com/viktorlarsson/openfigi)
+- [npm Package](https://www.npmjs.com/package/openfigi-sdk)
+
+## Acknowledgments
+
+Built with modern tools and technologies:
+- [Bun](https://bun.sh/) - Fast all-in-one JavaScript runtime
+- [TypeScript](https://www.typescriptlang.org/) - Type-safe JavaScript
+- [Vitest](https://vitest.dev/) - Fast unit testing framework
+- [Biome](https://biomejs.dev/) - Fast formatter and linter
+- [tsup](https://tsup.egoist.dev/) - Zero-config TypeScript bundler
+- [Zod](https://zod.dev/) - TypeScript-first validation

package/dist/index.cjs

@@ -0,0 +1,434 @@
+'use strict';
+
+var ky = require('ky');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ky__default = /*#__PURE__*/_interopDefault(ky);
+
+// src/client/client.ts
+
+// src/utils/errors.ts
+var OpenFigiError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "OpenFigiError";
+  }
+};
+var RateLimitError = class extends OpenFigiError {
+  constructor(message, retryAfter, statusCode) {
+    super(message, statusCode);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+var ValidationError = class extends OpenFigiError {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+};
+
+// src/utils/helpers.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseRateLimitHeaders(headers) {
+  const limit = headers.get("x-ratelimit-limit");
+  const remaining = headers.get("x-ratelimit-remaining");
+  const reset = headers.get("x-ratelimit-reset");
+  return {
+    limit: limit ? parseInt(limit, 10) : void 0,
+    remaining: remaining ? parseInt(remaining, 10) : void 0,
+    reset: reset ? new Date(parseInt(reset, 10) * 1e3) : void 0
+  };
+}
+function exponentialBackoff(attempt, baseDelay = 1e3, maxDelay = 3e4) {
+  const delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
+  const jitter = Math.random() * 0.1 * delay;
+  return Math.floor(delay + jitter);
+}
+var IdTypeSchema = zod.z.enum([
+  "ID_ISIN",
+  "ID_BB_UNIQUE",
+  "ID_SEDOL",
+  "ID_COMMON",
+  "ID_WERTPAPIER",
+  "ID_CUSIP",
+  "ID_BB",
+  "ID_ITALY",
+  "ID_EXCH_SYMBOL",
+  "ID_FULL_EXCHANGE_SYMBOL",
+  "COMPOSITE_ID_BB_GLOBAL",
+  "ID_BB_GLOBAL_SHARE_CLASS_LEVEL",
+  "ID_BB_GLOBAL",
+  "ID_BB_SEC_NUM_DES",
+  "ID_BB_SEC_NUM",
+  "ID_CINS",
+  "ID_BELGIUM",
+  "ID_DENMARK",
+  "ID_FRANCE",
+  "ID_JAPAN",
+  "ID_LUXEMBOURG",
+  "ID_NETHERLANDS",
+  "ID_POLAND",
+  "ID_PORTUGAL",
+  "ID_SWEDEN",
+  "ID_SHORT_CODE"
+]);
+var SecurityTypeSchema = zod.z.enum([
+  "Common Stock",
+  "Preference",
+  "ADR",
+  "Open-End Fund",
+  "Closed-End Fund",
+  "ETF",
+  "ETN",
+  "Unit",
+  "Mutual Fund",
+  "Money Market",
+  "Commodity",
+  "Currency",
+  "Option",
+  "Index"
+]);
+var MarketSectorSchema = zod.z.enum([
+  "All",
+  "Comdty",
+  "Curncy",
+  "Equity",
+  "Govt",
+  "Corp",
+  "Index",
+  "Money",
+  "Mtge",
+  "Muni",
+  "Pref"
+]);
+var MappingRequestSchema = zod.z.object({
+  idType: IdTypeSchema,
+  idValue: zod.z.string().min(1),
+  exchCode: zod.z.string().optional(),
+  micCode: zod.z.string().optional(),
+  currency: zod.z.string().length(3).optional(),
+  marketSecDes: MarketSectorSchema.optional(),
+  securityType: SecurityTypeSchema.optional(),
+  securityType2: zod.z.string().optional(),
+  includeUnlistedEquities: zod.z.boolean().optional(),
+  optionType: zod.z.enum(["Put", "Call"]).optional(),
+  strike: zod.z.array(zod.z.number()).optional(),
+  contractSize: zod.z.number().optional(),
+  coupon: zod.z.array(zod.z.number()).optional(),
+  expiration: zod.z.array(zod.z.number()).optional(),
+  maturity: zod.z.array(zod.z.number()).optional(),
+  stateCode: zod.z.string().length(2).optional()
+});
+var FigiResultSchema = zod.z.object({
+  figi: zod.z.string(),
+  securityType: SecurityTypeSchema.optional(),
+  marketSector: MarketSectorSchema.optional(),
+  ticker: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  exchCode: zod.z.string().optional(),
+  shareClassFIGI: zod.z.string().optional(),
+  compositeFIGI: zod.z.string().optional(),
+  securityType2: zod.z.string().optional(),
+  securityDescription: zod.z.string().optional(),
+  metadata: zod.z.string().optional()
+});
+var MappingResponseSchema = zod.z.object({
+  data: zod.z.array(FigiResultSchema).optional(),
+  warning: zod.z.string().optional(),
+  error: zod.z.string().optional()
+});
+zod.z.object({
+  error: zod.z.string(),
+  message: zod.z.string().optional(),
+  statusCode: zod.z.number().optional()
+});
+var ClientConfigSchema = zod.z.object({
+  apiKey: zod.z.string().optional(),
+  baseUrl: zod.z.string().url().optional(),
+  timeout: zod.z.number().positive().optional(),
+  retryLimit: zod.z.number().min(0).max(10).optional(),
+  retryDelay: zod.z.number().positive().optional(),
+  userAgent: zod.z.string().optional()
+});
+
+// src/client/client.ts
+var DEFAULT_CONFIG = {
+  apiKey: "",
+  baseUrl: "https://api.openfigi.com",
+  timeout: 3e4,
+  retryLimit: 3,
+  retryDelay: 1e3,
+  userAgent: "@openfigi/sdk"
+};
+var currentRateLimitInfo;
+var debugMode = false;
+var setDebugMode = (enabled) => {
+  debugMode = enabled;
+};
+var log = (level, message, ...args) => {
+  if (!debugMode) return;
+  const prefix = `[@openfigi/sdk] [${level.toUpperCase()}]`;
+  console[level](prefix, message, ...args);
+};
+var createHttpClient = (config) => {
+  return ky__default.default.create({
+    prefixUrl: config.baseUrl,
+    timeout: config.timeout,
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": config.userAgent,
+      ...config.apiKey && { "X-OPENFIGI-APIKEY": config.apiKey }
+    },
+    retry: {
+      limit: config.retryLimit,
+      methods: ["get", "post"],
+      statusCodes: [408, 413, 429, 500, 502, 503, 504]
+    },
+    hooks: {
+      beforeRequest: [
+        (request) => {
+          log("info", `Request: ${request.method} ${request.url}`);
+        }
+      ],
+      beforeRetry: [
+        async ({ error, retryCount }) => {
+          const delay = exponentialBackoff(retryCount, config.retryDelay);
+          log("warn", `Retry attempt ${retryCount} after ${delay}ms`, error.message);
+          await sleep(delay);
+        }
+      ],
+      afterResponse: [
+        (_request, _options, response) => {
+          const { limit, remaining, reset } = parseRateLimitHeaders(response.headers);
+          if (limit !== void 0 && remaining !== void 0 && reset) {
+            currentRateLimitInfo = { limit, remaining, reset };
+            log("info", `Rate limit: ${remaining}/${limit} (resets: ${reset.toISOString()})`);
+          }
+          log("info", `Response: ${response.status} ${response.statusText}`);
+          return response;
+        }
+      ]
+    }
+  });
+};
+var createClient = (config = {}) => {
+  const validation = ClientConfigSchema.safeParse(config);
+  if (!validation.success) {
+    const errors = validation.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    throw new ValidationError(`Invalid client configuration: ${errors}`, validation.error);
+  }
+  const finalConfig = { ...DEFAULT_CONFIG, ...config };
+  const httpClient = createHttpClient(finalConfig);
+  const mapping2 = async (requests) => {
+    if (!Array.isArray(requests) || requests.length === 0) {
+      throw new ValidationError(
+        "Requests must be a non-empty array. Provide at least one mapping request."
+      );
+    }
+    if (requests.length > 100) {
+      throw new ValidationError(
+        `Too many requests: ${requests.length}. Maximum 100 requests allowed per call. Split into multiple batches.`
+      );
+    }
+    const validatedRequests = requests.map((req, index) => {
+      const validation2 = MappingRequestSchema.safeParse(req);
+      if (!validation2.success) {
+        const errors = validation2.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+        throw new ValidationError(
+          `Invalid mapping request at index ${index}: ${errors}`,
+          validation2.error
+        );
+      }
+      return validation2.data;
+    });
+    try {
+      log("info", `Mapping ${validatedRequests.length} identifier(s)`);
+      const response = await httpClient.post("v3/mapping", {
+        json: validatedRequests
+      });
+      const data = await response.json();
+      if (!Array.isArray(data)) {
+        throw new OpenFigiError(
+          `Invalid API response: expected array but got ${typeof data}`,
+          response.status,
+          data
+        );
+      }
+      const validatedResponses = data.map((item, index) => {
+        const validation2 = MappingResponseSchema.safeParse(item);
+        if (!validation2.success) {
+          log("warn", `Invalid response at index ${index}:`, item, validation2.error);
+          return item;
+        }
+        return validation2.data;
+      });
+      log("info", `Mapped ${validatedResponses.length} identifier(s) successfully`);
+      return validatedResponses;
+    } catch (error) {
+      if (error instanceof OpenFigiError) {
+        throw error;
+      }
+      if (error instanceof Error && "response" in error) {
+        const httpError = error;
+        const status = httpError.response?.status;
+        if (status === 429) {
+          const retryAfter = httpError.response?.headers?.get("retry-after");
+          throw new RateLimitError(
+            "Rate limit exceeded. Please wait before making more requests.",
+            retryAfter ? parseInt(retryAfter, 10) : void 0,
+            status
+          );
+        }
+        if (status === 400) {
+          const body = await httpError.response?.text();
+          throw new ValidationError(`Bad request: ${body || "Invalid request format"}`);
+        }
+        if (status === 401) {
+          throw new OpenFigiError("Authentication failed. Check your API key.", status);
+        }
+        if (status === 404) {
+          throw new OpenFigiError("Endpoint not found. Please check the API version.", status);
+        }
+        throw new OpenFigiError(
+          `Request failed with status ${status}: ${httpError.message}`,
+          status,
+          await httpError.response?.text()
+        );
+      }
+      throw new OpenFigiError("Unexpected error occurred", void 0, error);
+    }
+  };
+  const mappingSingle2 = async (request) => {
+    const responses = await mapping2([request]);
+    return responses[0];
+  };
+  const searchByISIN2 = async (isin, options) => {
+    if (!isin || typeof isin !== "string") {
+      throw new ValidationError("ISIN must be a non-empty string");
+    }
+    return mappingSingle2({
+      idType: "ID_ISIN",
+      idValue: isin.trim(),
+      ...options
+    });
+  };
+  const searchByCUSIP2 = async (cusip, options) => {
+    if (!cusip || typeof cusip !== "string") {
+      throw new ValidationError("CUSIP must be a non-empty string");
+    }
+    return mappingSingle2({
+      idType: "ID_CUSIP",
+      idValue: cusip.trim(),
+      ...options
+    });
+  };
+  const searchBySEDOL2 = async (sedol, options) => {
+    if (!sedol || typeof sedol !== "string") {
+      throw new ValidationError("SEDOL must be a non-empty string");
+    }
+    return mappingSingle2({
+      idType: "ID_SEDOL",
+      idValue: sedol.trim(),
+      ...options
+    });
+  };
+  const searchByTicker2 = async (ticker, exchCode, options) => {
+    if (!ticker || typeof ticker !== "string") {
+      throw new ValidationError("Ticker must be a non-empty string");
+    }
+    return mappingSingle2({
+      idType: "ID_EXCH_SYMBOL",
+      idValue: ticker.trim().toUpperCase(),
+      exchCode: exchCode?.trim(),
+      ...options
+    });
+  };
+  const searchByBloombergId2 = async (bbgId, options) => {
+    if (!bbgId || typeof bbgId !== "string") {
+      throw new ValidationError("Bloomberg ID must be a non-empty string");
+    }
+    return mappingSingle2({
+      idType: "ID_BB_GLOBAL",
+      idValue: bbgId.trim(),
+      ...options
+    });
+  };
+  const getRateLimitInfo2 = () => {
+    return currentRateLimitInfo;
+  };
+  return {
+    mapping: mapping2,
+    mappingSingle: mappingSingle2,
+    searchByISIN: searchByISIN2,
+    searchByCUSIP: searchByCUSIP2,
+    searchBySEDOL: searchBySEDOL2,
+    searchByTicker: searchByTicker2,
+    searchByBloombergId: searchByBloombergId2,
+    getRateLimitInfo: getRateLimitInfo2
+  };
+};
+var defaultClient = createClient();
+var mapping = defaultClient.mapping;
+var mappingSingle = defaultClient.mappingSingle;
+var searchByISIN = defaultClient.searchByISIN;
+var searchByCUSIP = defaultClient.searchByCUSIP;
+var searchBySEDOL = defaultClient.searchBySEDOL;
+var searchByTicker = defaultClient.searchByTicker;
+var searchByBloombergId = defaultClient.searchByBloombergId;
+var getRateLimitInfo = defaultClient.getRateLimitInfo;
+
+// src/utils/validators.ts
+var isValidISIN = (isin) => {
+  return /^[A-Z]{2}[A-Z0-9]{9}[0-9]$/.test(isin);
+};
+var isValidCUSIP = (cusip) => {
+  return /^[A-Z0-9]{9}$/.test(cusip);
+};
+var isValidSEDOL = (sedol) => {
+  return /^[A-Z0-9]{7}$/.test(sedol);
+};
+var isValidBloombergId = (bbgId) => {
+  return /^BBG[A-Z0-9]{9}$/.test(bbgId);
+};
+var batchArray = (array, batchSize) => {
+  const batches = [];
+  for (let i = 0; i < array.length; i += batchSize) {
+    batches.push(array.slice(i, i + batchSize));
+  }
+  return batches;
+};
+
+exports.FigiResultSchema = FigiResultSchema;
+exports.IdTypeSchema = IdTypeSchema;
+exports.MappingRequestSchema = MappingRequestSchema;
+exports.MappingResponseSchema = MappingResponseSchema;
+exports.MarketSectorSchema = MarketSectorSchema;
+exports.OpenFigiError = OpenFigiError;
+exports.RateLimitError = RateLimitError;
+exports.SecurityTypeSchema = SecurityTypeSchema;
+exports.ValidationError = ValidationError;
+exports.batchArray = batchArray;
+exports.createClient = createClient;
+exports.getRateLimitInfo = getRateLimitInfo;
+exports.isValidBloombergId = isValidBloombergId;
+exports.isValidCUSIP = isValidCUSIP;
+exports.isValidISIN = isValidISIN;
+exports.isValidSEDOL = isValidSEDOL;
+exports.mapping = mapping;
+exports.mappingSingle = mappingSingle;
+exports.searchByBloombergId = searchByBloombergId;
+exports.searchByCUSIP = searchByCUSIP;
+exports.searchByISIN = searchByISIN;
+exports.searchBySEDOL = searchBySEDOL;
+exports.searchByTicker = searchByTicker;
+exports.setDebugMode = setDebugMode;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map