@toxplanet/pegasus-sdk 1.0.0 → 1.0.2

package/lib/search.js

@@ -1,19 +1,293 @@
+const { logInfo, logError } = require('@toxplanet/tphelper/logging');
+
+/**
+ * Detect if query looks like a CAS number (numbers with - or / separators)
+ * Returns array of alternative formats to try
+ * 
+ * CAS format: XXXXXXX-XX-X (registry-sequence-check)
+ * - First part: 2-7 digits (registry number)
+ * - Second part: ALWAYS 2 digits (zero-padded)
+ * - Third part: ALWAYS 1 digit (check digit)
+ */
+function getCasNumberVariations(query) {
+  // Check if it's all numbers and separators (-, /)
+  if (!/^[\d\-\/]+$/.test(query)) {
+    return [query]; // Not a CAS-like format, return as-is
+  }
+  
+  // Check if it has at least one separator
+  if (!query.includes('-') && !query.includes('/')) {
+    return [query]; // No separator, return as-is
+  }
+  
+  // Generate variations
+  const variations = new Set();
+  
+  // Add original
+  variations.add(query);
+  
+  // Split by any separator
+  const parts = query.split(/[-\/]/);
+  
+  if (parts.length === 3) {
+    // Three parts detected
+    // Could be:
+    // 1. Standard: registry-sequence-check (e.g., "7440-06-4")
+    // 2. Reversed: sequence/check/registry (e.g., "6/4/7440")
+    
+    const [part1, part2, part3] = parts;
+    
+    // Check if it looks like reversed format
+    // (small first part, small second part, large third part)
+    const isLikelyReversed = part1.length <= 2 && part2.length <= 2 && part3.length >= 3;
+    
+    if (isLikelyReversed) {
+      // Format: sequence/check/registry → registry-sequence-check
+      const registry = part3;
+      const sequence = part1.padStart(2, '0'); // Zero-pad to 2 digits
+      const check = part2;
+      
+      // Add properly formatted CAS
+      variations.add(`${registry}-${sequence}-${check}`);
+      variations.add(`${registry}/${sequence}/${check}`);
+    } else {
+      // Looks like standard format, try both separators
+      const registry = part1;
+      const sequence = part2.padStart(2, '0'); // Ensure 2 digits
+      const check = part3;
+      
+      variations.add(`${registry}-${sequence}-${check}`);
+      variations.add(`${registry}/${sequence}/${check}`);
+    }
+    
+    // Also try with different separator on original parts
+    variations.add(parts.join('-'));
+    variations.add(parts.join('/'));
+  } else if (parts.length === 2) {
+    // Two parts - just try both separators
+    variations.add(parts.join('-'));
+    variations.add(parts.join('/'));
+  }
+  
+  return Array.from(variations);
+}
+
 class SearchService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Search chemicals using OpenSearch with configurable boost parameters
+   * @param {string} query - Search query string
+   * @param {Object} options - Search options
+   * @param {number} options.limit - Maximum number of results (default: 10)
+   * @param {number} options.casExact - Boost for exact CAS matches (default: 50)
+   * @param {number} options.casPrefix - Boost for CAS prefix matches (default: 10)
+   * @param {number} options.nameExact - Boost for exact name matches (default: 40)
+   * @param {number} options.namePrefix - Boost for name prefix matches (default: 8)
+   * @param {number} options.identifierExact - Boost for exact identifier matches (default: 30)
+   * @param {number} options.identifierPrefix - Boost for identifier prefix matches (default: 5)
+   * @param {number} options.synonymExact - Boost for exact synonym matches (default: 100)
+   * @param {number} options.synonymPrefix - Boost for synonym prefix matches (default: 3)
+   * @returns {Promise<Object>} Search results with chemicals array
+   */
+  async searchChemicals(query, options = {}) {
+    if (!query) {
+      return { results: [] };
+    }
 
-  async searchChemicals(searchTerm, searchType, limit, offset) {}
+    // Extract options with defaults
+    const limit = options.limit || 10;
+    const casExact = options.casExact !== undefined ? options.casExact : 50;
+    const casPrefix = options.casPrefix !== undefined ? options.casPrefix : 10;
+    const nameExact = options.nameExact !== undefined ? options.nameExact : 40;
+    const namePrefix = options.namePrefix !== undefined ? options.namePrefix : 8;
+    const identifierExact = options.identifierExact !== undefined ? options.identifierExact : 30;
+    const identifierPrefix = options.identifierPrefix !== undefined ? options.identifierPrefix : 5;
+    const synonymExact = options.synonymExact !== undefined ? options.synonymExact : 100;
+    const synonymPrefix = options.synonymPrefix !== undefined ? options.synonymPrefix : 3;
 
-  async searchStartsWith(searchTerm, limit) {}
+    try {
+      const opensearchClient = this.connection.getOpenSearchClient();
+      
+      // Get CAS number variations (if applicable)
+      const queryVariations = getCasNumberVariations(query);
+      
+      // Log if we're trying multiple variations
+      if (queryVariations.length > 1) {
+        logInfo('pegasus-sdk', `CAS format detection: trying ${queryVariations.length} variations for "${query}": ${JSON.stringify(queryVariations)}`);
+      }
+      
+      // Build should clauses for all query variations
+      const shouldClauses = [];
+      
+      for (const queryVariation of queryVariations) {
+        // Exact matches (configurable priority)
+        shouldClauses.push(
+          { term: { 'cas_numbers': { value: queryVariation, boost: casExact } } },
+          { term: { 'chemical_name.keyword': { value: queryVariation, boost: nameExact, case_insensitive: true } } },
+          { term: { 'identifier_values': { value: queryVariation, boost: identifierExact } } },
+          { term: { 'synonyms.keyword': { value: queryVariation, boost: synonymExact, case_insensitive: true } } },
+          // Prefix matches (configurable priority)
+          { prefix: { 'cas_numbers': { value: queryVariation, boost: casPrefix } } },
+          { prefix: { 'chemical_name.keyword': { value: queryVariation, boost: namePrefix, case_insensitive: true } } },
+          { prefix: { 'identifier_values': { value: queryVariation, boost: identifierPrefix } } },
+          { prefix: { 'synonyms.keyword': { value: queryVariation, boost: synonymPrefix, case_insensitive: true } } }
+        );
+      }
+      
+      const indexName = this.connection.getOpenSearchIndex();
+      
+      const response = await opensearchClient.search({
+        index: indexName,
+        body: {
+          size: limit,
+          query: {
+            bool: {
+              should: shouldClauses,
+              minimum_should_match: 1
+            }
+          },
+          _source: ['postgres_id', 'chemical_name', 'cas_numbers', 'identifier_values', 'synonyms']
+        }
+      });
 
-  async searchContains(searchTerm, limit) {}
+      const hits = response.body?.hits?.hits || [];
+      const results = hits.map((hit) => ({
+        id: hit._source.postgres_id,
+        name: hit._source.chemical_name,
+        cas: hit._source.cas_numbers || [],
+        identifiers: hit._source.identifier_values || [],
+        synonyms: hit._source.synonyms || [],
+        score: hit._score
+      }));
 
-  async searchExact(searchTerm, limit) {}
+      return { results };
+    } catch (error) {
+      logError('pegasus-sdk', 'SearchService', 'searchChemicals', error);
+      throw error;
+    }
+  }
 
-  async searchByCAS(casNumber, searchType) {}
+  /**
+   * Search for chemicals with prefix matching priority
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchStartsWith(searchTerm, limit = 10) {
+    return this.searchChemicals(searchTerm, {
+      limit,
+      // Prioritize prefix matches over exact matches
+      casPrefix: 50,
+      casExact: 20,
+      namePrefix: 40,
+      nameExact: 15,
+      identifierPrefix: 30,
+      identifierExact: 10,
+      synonymPrefix: 35,
+      synonymExact: 10
+    });
+  }
 
-  async searchByIdentifier(identifierValue, searchType) {}
+  /**
+   * Search for chemicals (alias for general search)
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchContains(searchTerm, limit = 10) {
+    // Use default balanced weights for contains search
+    return this.searchChemicals(searchTerm, { limit });
+  }
 
-  async searchBySynonym(synonymTerm, searchType) {}
+  /**
+   * Search for chemicals with exact matching priority
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchExact(searchTerm, limit = 10) {
+    return this.searchChemicals(searchTerm, {
+      limit,
+      // Prioritize exact matches, minimize prefix matches
+      casExact: 100,
+      casPrefix: 1,
+      nameExact: 80,
+      namePrefix: 1,
+      identifierExact: 60,
+      identifierPrefix: 1,
+      synonymExact: 150,
+      synonymPrefix: 1
+    });
+  }
+
+  /**
+   * Search for chemicals by CAS number
+   * @param {string} casNumber - CAS number to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByCAS(casNumber, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(casNumber, {
+      limit: 10,
+      // Heavily prioritize CAS field
+      casExact: isExact ? 200 : 50,
+      casPrefix: isExact ? 10 : 100,
+      nameExact: 5,
+      namePrefix: 1,
+      identifierExact: 5,
+      identifierPrefix: 1,
+      synonymExact: 5,
+      synonymPrefix: 1
+    });
+  }
+
+  /**
+   * Search for chemicals by identifier value
+   * @param {string} identifierValue - Identifier value to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByIdentifier(identifierValue, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(identifierValue, {
+      limit: 10,
+      // Heavily prioritize identifier field
+      identifierExact: isExact ? 200 : 50,
+      identifierPrefix: isExact ? 10 : 100,
+      casExact: 10,
+      casPrefix: 5,
+      nameExact: 5,
+      namePrefix: 1,
+      synonymExact: 5,
+      synonymPrefix: 1
+    });
+  }
+
+  /**
+   * Search for chemicals by synonym
+   * @param {string} synonymTerm - Synonym term to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchBySynonym(synonymTerm, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(synonymTerm, {
+      limit: 10,
+      // Heavily prioritize synonym field
+      synonymExact: isExact ? 200 : 50,
+      synonymPrefix: isExact ? 10 : 100,
+      nameExact: 20,
+      namePrefix: 5,
+      casExact: 10,
+      casPrefix: 5,
+      identifierExact: 5,
+      identifierPrefix: 1
+    });
+  }
 
   async advancedSearch(queryBuilder) {}
 
@@ -28,6 +302,35 @@ class SearchService {
   async getSearchSuggestions(partialTerm, limit) {}
 
   async findSimilarChemicals(chemicalId, limit) {}
+
+  registerElasticsearchHandlers(elasticsearchService) {
+    const indexPatterns = this.connection.config.indexRoutes?.search || [/^(chemicals|substances|search)/];
+    
+    indexPatterns.forEach(pattern => {
+      elasticsearchService.registerIndexRoute(pattern, {
+      search: async (params) => {
+        const query = params.body?.query;
+        const searchTerm = query?.match?.chemical_name || 
+                          query?.term?.chemical_name || 
+                          query?.query_string?.query || 
+                          query?.match_all ? '*' : '';
+        const limit = params.body?.size || 10;
+        
+        return await this.searchChemicals(searchTerm, { limit });
+      },
+      
+      count: async (params) => {
+        const query = params.body?.query;
+        const searchTerm = query?.match?.chemical_name || 
+                          query?.term?.chemical_name || 
+                          query?.query_string?.query || '';
+        
+        const results = await this.searchChemicals(searchTerm, { limit: 10000 });
+        return { count: results.results.length };
+      }
+      });
+    });
+  }
 }
 
 module.exports = SearchService;

package/lib/sync.js

@@ -1,5 +1,7 @@
 class SyncService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+  }
 
   async syncBatch(batchSize) {}
 

package/lib/utils.js

@@ -1,5 +1,7 @@
 class UtilsService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+  }
 
   async executeBatch(operations, batchSize, concurrency) {}
 

package/package.json

@@ -1,23 +1,48 @@
 {
   "name": "@toxplanet/pegasus-sdk",
-  "version": "1.0.0",
-  "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture",
+  "version": "1.0.2",
+  "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture with Elasticsearch client compatibility",
   "main": "index.js",
+  "type": "commonjs",
   "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui"
   },
   "keywords": [
+    "elasticsearch",
+    "opensearch",
+    "postgresql",
+    "aws",
+    "chemicals",
+    "database",
+    "search",
+    "sdk",
+    "pegasus",
+    "migration"
   ],
   "author": "Chemical Research Development Team",
   "license": "MIT",
   "dependencies": {
+    "@toxplanet/tphelper": "1.2.8",
     "pg": "^8.11.3",
+    "drizzle-orm": "^0.30.0",
     "@opensearch-project/opensearch": "^2.5.0",
-    "@aws-sdk/client-opensearch-serverless": "^3.490.0",
     "@aws-sdk/client-secrets-manager": "^3.490.0",
-    "@aws-sdk/credential-providers": "^3.490.0",
-    "aws4fetch": "^1.0.18"
+    "@aws-sdk/credential-providers": "^3.490.0"
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "config/",
+    "README.md",
+    "ELASTICSEARCH_CLIENT.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "vitest": "^1.2.0"
   }
 }

package/env.example

@@ -1,3 +0,0 @@
-NODE_ENV=development
-AWS_REGION=us-east-1
-OPENSEARCH_ENDPOINT=https://your-collection.us-east-1.aoss.amazonaws.com

package/index.d.ts

@@ -1,215 +0,0 @@
-export interface PegasusConfig {
-  environment?: string;
-  region?: string;
-  secretName?: string;
-  openSearchEndpoint?: string;
-  maxConnections?: number;
-  minConnections?: number;
-  idleTimeoutMillis?: number;
-  connectionTimeoutMillis?: number;
-  statementTimeout?: number;
-  queryTimeout?: number;
-}
-
-export interface Chemical {
-  chemical_id?: string;
-  source_id: string;
-  chemical_name: string;
-  chemical_identifiers: Identifier[];
-  chemical_synonyms: string[];
-  chemical_categories: string[];
-  chemical_meta: Record<string, any>;
-  created_at?: Date;
-  updated_at?: Date;
-}
-
-export interface Identifier {
-  type: string;
-  value: string;
-}
-
-export interface Document {
-  document_id?: string;
-  document_path: string;
-  processed_at?: Date;
-  cas_count?: number;
-}
-
-export interface OutboxEntry {
-  outbox_id: number;
-  chemical_id: string;
-  operation: 'INSERT' | 'UPDATE' | 'DELETE';
-  created_at: Date;
-  processed_at?: Date;
-  retry_count: number;
-  last_error?: string;
-}
-
-export interface ConnectionStatus {
-  postgres: {
-    connected: boolean;
-    timestamp?: Date;
-    version?: string;
-    poolSize?: number;
-    idleConnections?: number;
-    waitingRequests?: number;
-    error?: string;
-  };
-  opensearch: {
-    connected: boolean;
-    version?: string;
-    cluster?: string;
-    error?: string;
-  } | null;
-  environment: string;
-  region: string;
-}
-
-export declare class PegasusConnection {
-  constructor(config?: PegasusConfig);
-  getSecret(): Promise<any>;
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-  getPostgresClient(): any;
-  getOpenSearchClient(): any;
-  testConnection(): Promise<ConnectionStatus>;
-  query(sql: string, params?: any[]): Promise<any>;
-  getClient(): Promise<any>;
-  transaction(callback: (client: any) => Promise<any>): Promise<any>;
-}
-
-export declare class ChemicalsService {
-  constructor(connection: PegasusConnection);
-  bulkIndexFielded(documents: any[]): Promise<void>;
-  bulkIndexFulltext(documents: any[]): Promise<void>;
-  bulkIndexSubstances(substances: any[]): Promise<void>;
-  createChemical(chemical: Chemical): Promise<Chemical>;
-  updateChemical(chemicalId: string, updates: Partial<Chemical>): Promise<Chemical>;
-  deleteChemical(chemicalId: string): Promise<void>;
-  deleteBySourceId(sourceId: string): Promise<void>;
-  deleteCollection(collectionName: string): Promise<number>;
-  updateCollectionProperty(collectionName: string, propertyPath: string, newValue: any): Promise<number>;
-  bulkUpdateProperty(filter: any, propertyPath: string, newValue: any): Promise<number>;
-  getChemicalById(chemicalId: string): Promise<Chemical>;
-  getChemicalBySourceId(sourceId: string): Promise<Chemical>;
-  getChemicalsByCAS(casNumber: string): Promise<Chemical[]>;
-  getChemicalsByIdentifier(identifierType: string, identifierValue: string): Promise<Chemical[]>;
-  countAll(): Promise<number>;
-  countByCollection(collectionName: string): Promise<number>;
-  countByIdentifier(identifierValue: string): Promise<number>;
-  countByCAS(casNumber: string): Promise<number>;
-  getTotalSynonymCount(): Promise<number>;
-  getSynonymCount(synonymTerm: string): Promise<number>;
-  convertIdentifier(fromIdentifier: string, toIdentifierType: string): Promise<any>;
-  convertIdentifiersBatch(fromIdentifiers: string[], toIdentifierType: string): Promise<any[]>;
-  searchByName(searchTerm: string, limit: number): Promise<Chemical[]>;
-  searchBySynonym(synonymTerm: string, limit: number): Promise<Chemical[]>;
-  findChemicalsWithoutDocuments(collectionName: string, searchTerm: string, pageSize: number): Promise<Chemical[]>;
-  countChemicalsWithoutDocuments(collectionName: string): Promise<number>;
-}
-
-export declare class DocumentsService {
-  constructor(connection: PegasusConnection);
-  createDocument(documentPath: string, casNumbers: string[]): Promise<Document>;
-  bulkCreateDocuments(documents: any[]): Promise<void>;
-  updateDocument(documentId: string, updates: Partial<Document>): Promise<Document>;
-  deleteDocument(documentId: string): Promise<void>;
-  deleteDocumentByPath(documentPath: string): Promise<void>;
-  getDocumentById(documentId: string): Promise<Document>;
-  getDocumentByPath(documentPath: string): Promise<Document>;
-  getDocumentsByCAS(casNumber: string): Promise<Document[]>;
-  getCASByDocument(documentId: string): Promise<string[]>;
-  getCASByDocumentPath(documentPath: string): Promise<string[]>;
-  addCASToDocument(documentId: string, casNumber: string): Promise<void>;
-  addCASToDocumentBatch(documentId: string, casNumbers: string[]): Promise<void>;
-  removeCASFromDocument(documentId: string, casNumber: string): Promise<void>;
-  findDocumentsWithMultipleCAS(casNumbers: string[], requireAll: boolean): Promise<Document[]>;
-  countDocuments(): Promise<number>;
-  countDocumentsByCAS(casNumber: string): Promise<number>;
-  countUniqueCAS(): Promise<number>;
-  getTopCASByDocumentCount(limit: number): Promise<any[]>;
-  extractTextFromPDF(pdfBuffer: Buffer): Promise<string>;
-  extractCASFromText(text: string): Promise<string[]>;
-  processDocument(documentPath: string, documentData: any): Promise<Document>;
-}
-
-export declare class SearchService {
-  constructor(connection: PegasusConnection);
-  searchChemicals(searchTerm: string, searchType: string, limit: number, offset: number): Promise<any[]>;
-  searchStartsWith(searchTerm: string, limit: number): Promise<any[]>;
-  searchContains(searchTerm: string, limit: number): Promise<any[]>;
-  searchExact(searchTerm: string, limit: number): Promise<any[]>;
-  searchByCAS(casNumber: string, searchType: string): Promise<any[]>;
-  searchByIdentifier(identifierValue: string, searchType: string): Promise<any[]>;
-  searchBySynonym(synonymTerm: string, searchType: string): Promise<any[]>;
-  advancedSearch(queryBuilder: any): Promise<any[]>;
-  searchWithFilters(searchTerm: string, filters: any, limit: number): Promise<any[]>;
-  searchByCollection(collectionName: string, searchTerm: string, limit: number): Promise<any[]>;
-  aggregateByCategory(): Promise<any>;
-  aggregateByIdentifierType(): Promise<any>;
-  getSearchSuggestions(partialTerm: string, limit: number): Promise<string[]>;
-  findSimilarChemicals(chemicalId: string, limit: number): Promise<any[]>;
-}
-
-export declare class SyncService {
-  constructor(connection: PegasusConnection);
-  syncBatch(batchSize: number): Promise<number>;
-  syncAll(): Promise<number>;
-  syncContinuous(intervalMs: number): Promise<void>;
-  stopContinuousSync(): Promise<void>;
-  getPendingCount(): Promise<number>;
-  getOldestPending(): Promise<Date>;
-  getSyncLag(): Promise<number>;
-  getFailedEntries(minRetryCount: number): Promise<OutboxEntry[]>;
-  retryFailed(outboxId: number): Promise<void>;
-  retryAllFailed(): Promise<number>;
-  markAsProcessed(outboxId: number): Promise<void>;
-  deleteProcessedOlderThan(days: number): Promise<number>;
-  cleanupOutbox(daysToKeep: number): Promise<number>;
-  getSyncStats(timeWindowMinutes: number): Promise<any>;
-  getSyncThroughput(): Promise<number>;
-  verifySync(chemicalId: string): Promise<boolean>;
-  forceResync(chemicalId: string): Promise<void>;
-  getOutboxHealth(): Promise<any>;
-}
-
-
-export declare class UtilsService {
-  constructor(connection: PegasusConnection);
-  executeBatch(operations: any[], batchSize: number, concurrency: number): Promise<void>;
-  withTransaction(callback: () => Promise<any>): Promise<any>;
-  withRetry(operation: () => Promise<any>, maxRetries: number, backoffMs: number): Promise<any>;
-  validateChemical(chemical: Chemical): boolean;
-  validateDocument(document: Document): boolean;
-  validateIdentifier(identifier: Identifier): boolean;
-  validateCAS(casNumber: string): boolean;
-  transformForOpenSearch(chemical: Chemical): any;
-  transformFromElasticsearch(esDocument: any): Chemical;
-  transformFromDynamoDB(dynamoItem: any): Chemical;
-  buildOpenSearchQuery(searchTerm: string, searchType: string): any;
-  buildPostgresFilter(filters: any): any;
-  parseChemicalIdentifiers(identifiers: any): Identifier[];
-  parseSynonyms(synonyms: any): string[];
-  extractCASFromText(text: string): string[];
-  sanitizeSearchTerm(term: string): string;
-  generateSourceId(chemical: Chemical): string;
-  calculateChecksum(data: any): string;
-  formatError(error: Error): any;
-  logOperation(operation: string, duration: number, metadata: any): void;
-  getTimestamp(): Date;
-}
-
-
-export default class PegasusSDK {
-  connection: PegasusConnection;
-  chemicals: ChemicalsService;
-  documents: DocumentsService;
-  search: SearchService;
-  sync: SyncService;
-  utils: UtilsService;
-
-  constructor(config: PegasusConfig);
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-  healthCheck(): Promise<any>;
-}