@memberjunction/actions-apollo 2.79.0 → 2.80.0

package/README.md

@@ -36,9 +36,12 @@ APOLLO_API_KEY=your_apollo_api_key_here
 
 The package uses the following configuration values (defined in `config.ts`):
 
+- `ApolloAPIEndpoint`: 'https://api.apollo.io/v1' - Apollo.io API base URL
+- `EmailSourceName`: 'Apollo.io' - Source name for enriched emails
 - `GroupSize`: 10 - Maximum records per API batch request
 - `ConcurrentGroups`: 1 - Number of concurrent API request groups
 - `MaxPeopleToEnrichPerOrg`: 500 - Maximum contacts to enrich per organization
+- `ApolloAPIKey`: Read from environment variable `APOLLO_API_KEY`
 
 ## Usage
 
@@ -48,53 +51,49 @@ This action enriches account/organization records by looking up company informat
 
 #### Parameters
 
+The action accepts the following parameters as JSON strings:
+
+**Required:**
+- `AccountEntityFieldNameJSON` - Maps account entity fields
+
+**Optional:**
+- `AccountTechnologyEntityFieldNameJSON` - Maps account technology relationship fields
+- `TechnologyCategoryEntityFieldNameJSON` - Maps technology category fields  
+- `ContactEntityFieldNameJSON` - Maps contact entity fields
+- `ContactEducationHistoryEntityFieldNameJSON` - Maps contact education history fields
+
+**AccountEntityFieldNameJSON Structure:**
 ```typescript
 {
-  // Required - JSON mapping for account entity fields
-  AccountEntityFieldNameJSON: {
-    EntityName: "Accounts",
-    DomainParamName: "Domain",
-    AccountIDName: "ID",
-    EnrichedAtField: "LastEnrichedAt",
-    AddressFieldName: "Address",
-    CityFieldNameName: "City",
-    StateProvinceFieldName: "State",
-    PostalCodeFieldName: "PostalCode",
-    DescriptionFieldName: "Description",
-    PhoneNumberFieldName: "Phone",
-    CountryFieldName: "Country",
-    LinkedInFieldName: "LinkedIn",
-    LogoURLFieldName: "LogoURL",
-    FacebookFieldName: "Facebook",
-    TwitterFieldName: "Twitter",
-    ExtraFilter: "Domain IS NOT NULL AND LastEnrichedAt IS NULL"
-  },
-
-  // Optional - JSON mapping for technology tracking
-  AccountTechnologyEntityFieldNameJSON: {
-    EntityName: "AccountTechnologies",
-    AccountIDFieldName: "AccountID",
-    TechnologyIDFieldName: "TechnologyID",
-    MatchFoundFieldName: "MatchFound",
-    EndedUseAtFieldName: "EndedAt"
-  },
-
-  // Optional - JSON mapping for technology categories
-  TechnologyCategoryEntityFieldNameJSON: {
-    EntityName: "TechnologyCategories",
-    NameFieldName: "Name",
-    IDFieldName: "ID"
-  },
-
-  // Optional - JSON mapping for contacts
-  ContactEntityFieldNameJSON: {
-    EntityName: "Contacts",
-    EmailFieldName: "Email",
-    AccountIDFieldName: "AccountID",
-    FirstNameFieldName: "FirstName",
-    LastNameFieldName: "LastName",
-    // ... other field mappings
-  }
+  EntityName: string;           // Target entity name (e.g., "Accounts")
+  DomainParamName: string;      // Field containing company domain
+  AccountIDName: string;        // Primary key field name
+  EnrichedAtField: string;      // Timestamp field for tracking enrichment
+  ExtraFilter?: string;         // SQL filter for selecting records to process
+  
+  // Optional mapping fields
+  AddressFieldName?: string;    // Street address field
+  CityFieldNameName?: string;   // City field
+  StateProvinceFieldName?: string; // State/province field
+  PostalCodeFieldName?: string; // Postal code field
+  DescriptionFieldName?: string; // Company description field
+  PhoneNumberFieldName?: string; // Phone number field
+  CountryFieldName?: string;    // Country field
+  LinkedInFieldName?: string;   // LinkedIn URL field
+  LogoURLFieldName?: string;    // Company logo URL field
+  FacebookFieldName?: string;   // Facebook URL field
+  TwitterFieldName?: string;    // Twitter URL field
+}
+```
+
+**AccountTechnologyEntityFieldNameJSON Structure:**
+```typescript
+{
+  EntityName: string;              // Technology relationship entity name
+  AccountIDFieldName: string;      // Foreign key to account
+  TechnologyIDFieldName: string;   // Foreign key to technology
+  MatchFoundFieldName: string;     // Field indicating if match was found
+  EndedUseAtFieldName: string;     // Field for marking end of technology use
 }
 ```
 
@@ -133,33 +132,40 @@ This action enriches contact records by matching on name and email combinations.
 
 #### Parameters
 
+The action accepts the following string parameters:
+
+**Required:**
+- `EntityName` - Target entity name containing contacts
+- `EmailField` - Field name containing email addresses  
+- `FirstNameField` - Field name containing first names
+- `LastNameField` - Field name containing last names
+- `AccountNameField` - Field name containing account/organization names
+- `EnrichedAtField` - Field name for tracking enrichment timestamp
+- `FilterParam` - SQL filter for selecting records to process
+
+**Optional:**
+- `domainParam` - Field name containing company domain
+- `linkedinParam` - Field name for storing LinkedIn URLs
+- `EmploymentHistoryFieldMappings` - JSON string with employment history field mappings
+- `EducationHistoryFieldMappings` - JSON string with education history field mappings
+
+**EmploymentHistoryFieldMappings Structure:**
 ```typescript
 {
-  EntityName: "Contacts",              // Target entity name
-  EmailField: "Email",                 // Email field name
-  FirstNameField: "FirstName",         // First name field name
-  LastNameField: "LastName",           // Last name field name
-  AccountNameField: "AccountName",     // Account name field name
-  EnrichedAtField: "LastEnrichedAt",  // Enrichment timestamp field
-  FilterParam: "Email IS NOT NULL",    // Filter for records to enrich
-  domainParam: "Domain",               // Domain field name (optional)
-  linkedinParam: "LinkedIn",           // LinkedIn URL field name (optional)
-  
-  // Optional - Employment history field mappings
-  EmploymentHistoryFieldMappings: {
-    EmploymentHistoryEntityName: "ContactEmploymentHistory",
-    EmploymentHistoryContactIDFieldName: "ContactID",
-    EmploymentHistoryOrganizationFieldName: "Organization",
-    EmploymentHistoryTitleFieldName: "Title"
-  },
-  
-  // Optional - Education history field mappings
-  EducationHistoryFieldMappings: {
-    EducationHistoryEntityName: "ContactEducationHistory",
-    EducationtHistoryContactIDFieldName: "ContactID",
-    EducationtHistoryInstitutionFieldName: "Institution",
-    EducationtHistoryDegreeFieldName: "Degree"
-  }
+  EmploymentHistoryEntityName: string;              // Employment history entity name
+  EmploymentHistoryContactIDFieldName: string;      // Foreign key to contact
+  EmploymentHistoryOrganizationFieldName: string;   // Organization name field
+  EmploymentHistoryTitleFieldName: string;          // Job title field
+}
+```
+
+**EducationHistoryFieldMappings Structure:**
+```typescript
+{
+  EducationHistoryEntityName: string;              // Education history entity name
+  EducationtHistoryContactIDFieldName: string;     // Foreign key to contact  
+  EducationtHistoryInstitutionFieldName: string;   // Institution name field
+  EducationtHistoryDegreeFieldName: string;        // Degree field
 }
 ```
 
@@ -169,7 +175,7 @@ This action enriches contact records by matching on name and email combinations.
 import { ApolloContactsEnrichmentAction } from '@memberjunction/actions-apollo';
 
 const result = await engine.RunAction({
-  ActionName: 'Apollo Enrichment - Contacts',
+  ActionName: 'Apollo Enrichment - Contacts', 
   Params: [
     { Name: 'EntityName', Value: 'Contacts' },
     { Name: 'EmailField', Value: 'Email' },
@@ -177,7 +183,18 @@ const result = await engine.RunAction({
     { Name: 'LastNameField', Value: 'LastName' },
     { Name: 'AccountNameField', Value: 'AccountName' },
     { Name: 'EnrichedAtField', Value: 'LastEnrichedAt' },
-    { Name: 'FilterParam', Value: 'Email IS NOT NULL AND LastEnrichedAt IS NULL' }
+    { Name: 'FilterParam', Value: 'Email IS NOT NULL AND LastEnrichedAt IS NULL' },
+    { Name: 'domainParam', Value: 'Domain' },
+    { Name: 'linkedinParam', Value: 'LinkedIn' },
+    { 
+      Name: 'EmploymentHistoryFieldMappings', 
+      Value: JSON.stringify({
+        EmploymentHistoryEntityName: 'ContactEmploymentHistory',
+        EmploymentHistoryContactIDFieldName: 'ContactID',
+        EmploymentHistoryOrganizationFieldName: 'Organization', 
+        EmploymentHistoryTitleFieldName: 'Title'
+      })
+    }
   ],
   ContextUser: currentUser
 });
@@ -193,17 +210,21 @@ const result = await engine.RunAction({
 - Historical technology usage tracking
 
 ### Contact Enrichment
-- Email verification and discovery
-- Employment history tracking
-- Education history tracking
-- Social media profile URLs
-- Title exclusion filtering (excludes students, volunteers, etc.)
+- Bulk email verification and discovery (up to 10 contacts per API call)
+- Employment history tracking with date ranges
+- Education history tracking with degree information
+- Social media profile URLs (LinkedIn, Twitter, Facebook)
+- Title exclusion filtering (excludes members, students, volunteers)
+- Pagination support for processing large datasets
+- Duplicate contact detection across accounts
 
 ### Error Handling & Rate Limiting
-- Automatic retry with exponential backoff for rate limits
-- Handles both per-minute and per-hour rate limits
-- Comprehensive error logging
-- Batch processing to optimize API usage
+- Automatic retry with intelligent backoff for rate limits (1 minute for general limits, 1 hour for hourly limits)
+- Handles both per-minute and per-hour rate limits with different wait times
+- Comprehensive error logging using MemberJunction's logging system
+- Batch processing to optimize API usage and respect Apollo.io limits
+- Graceful handling of missing or incomplete data
+- Transaction rollback support for failed operations
 
 ## API Integration
 
@@ -236,9 +257,12 @@ The package integrates with the following Apollo.io API endpoints:
 ## Limitations
 
 - Maximum 10 records per bulk API request (Apollo.io limitation)
-- Rate limits apply based on your Apollo.io subscription
+- Rate limits apply based on your Apollo.io subscription (handled automatically with retries)
 - Personal emails may not be revealed in GDPR-compliant regions
 - Some enrichment data may be incomplete depending on Apollo.io's data coverage
+- Account enrichment processes domains sequentially to avoid overwhelming the system
+- Contact enrichment uses pagination with a maximum of 500 contacts per organization
+- Excluded job titles (member, student member, student, volunteer) are automatically skipped
 
 ## Troubleshooting
 

package/dist/accounts.d.ts

@@ -1,25 +1,335 @@
 import { BaseAction } from "@memberjunction/actions";
-import { BaseEntity, Metadata, UserInfo } from "@memberjunction/core";
+import { Metadata, UserInfo } from "@memberjunction/core";
 import { AxiosResponse } from "axios";
-import { ProcessSingleDomainParams, SearchPeopleResponsePerson, TechnologyMap } from "./generic/apollo.types";
+import { ProcessSingleDomainParams, TechnologyMap } from "./generic/apollo.types";
 import { ActionResultSimple, RunActionParams } from "@memberjunction/actions-base";
-export declare class ApolloAccountsEnrichmentAction extends BaseAction {
-    private ExcludeTitles;
+/**
+ * Action that enriches account records using Apollo.io's organization and people data
+ *
+ * This action performs comprehensive account enrichment by:
+ * 1. Enriching organization data (address, phone, social profiles, etc.)
+ * 2. Creating technology stack records for the organization
+ * 3. Finding and enriching contacts associated with the organization
+ * 4. Creating employment/education history for contacts
+ *
+ * @example
+ * ```typescript
+ * // Basic account enrichment
+ * await runAction({
+ *   ActionName: 'ApolloEnrichmentAccountsAction',
+ *   Params: [{
+ *     Name: 'AccountEntityFieldMappings',
+ *     Value: JSON.stringify({
+ *       EntityName: 'Accounts',
+ *       Filter: 'Domain IS NOT NULL AND EnrichedAt IS NULL',
+ *       DomainField: 'Domain',
+ *       AccountIDField: 'ID',
+ *       EnrichedAtField: 'EnrichedAt'
+ *     })
+ *   }]
+ * });
+ *
+ * // Full enrichment with contacts and technologies
+ * await runAction({
+ *   ActionName: 'ApolloEnrichmentAccountsAction',
+ *   Params: [{
+ *     Name: 'AccountEntityFieldMappings',
+ *     Value: JSON.stringify(accountConfig)
+ *   }, {
+ *     Name: 'ContactEntityFieldMappings',
+ *     Value: JSON.stringify(contactConfig)
+ *   }, {
+ *     Name: 'AccountTechnologyEntityFieldMappings',
+ *     Value: JSON.stringify(technologyConfig)
+ *   }]
+ * });
+ * ```
+ */
+export declare class ApolloEnrichmentAccountsAction extends BaseAction {
+    /**
+     * Job titles to exclude when creating contact records
+     * These are typically not decision-makers or relevant contacts
+     */
+    private readonly ExcludeTitles;
+    /**
+     * Main entry point for the Apollo account enrichment action
+     *
+     * @param params - The action parameters containing:
+     *   - AccountEntityFieldMappings: Required JSON configuration for account entity field mappings
+     *   - ContactEntityFieldMappings: Optional JSON configuration for contact entity field mappings
+     *   - AccountTechnologyEntityFieldMappings: Optional JSON configuration for technology tracking
+     *   - TechnologyCategoryEntityFieldMappings: Optional JSON configuration for technology categories
+     *   - ContactEducationHistoryEntityFieldMappings: Optional JSON configuration for education history
+     *
+     * @returns Promise<ActionResultSimple> indicating success/failure and any error messages
+     */
     protected InternalRunAction(params: RunActionParams): Promise<ActionResultSimple>;
+    /**
+     * Validates that the Apollo.io API key is configured properly
+     * @returns Validation result with success flag and potential error details
+     */
+    private validateConfiguration;
+    /**
+     * Extracts and validates all action parameters from the request
+     *
+     * @param params - The action parameters containing JSON configurations
+     * @returns Object with success flag, validated parameters, or error details
+     */
+    private extractAndValidateParameters;
+    /**
+     * Gets a required parameter from the action parameters
+     * @param params - The action parameters
+     * @param paramName - Name of the required parameter
+     * @returns The parameter if found, null otherwise
+     */
+    private getRequiredParam;
+    /**
+     * Parses an optional JSON parameter with error handling
+     * @param params - The action parameters
+     * @param paramName - Name of the optional JSON parameter
+     * @returns Parsed object of type T or null if not provided/invalid
+     */
+    private parseOptionalJSONParam;
+    /**
+     * Parses a parameter value that may be a JSON string or already parsed object
+     * Handles the case where action parameters ending with JSON can be either strings or objects
+     *
+     * @param value - The parameter value to parse (string or object)
+     * @returns Parsed object of type T
+     * @throws Error if value cannot be parsed as JSON (when it's a string)
+     */
+    private parseJSONParam;
+    /**
+     * Recursively processes all account records that match the filter criteria
+     * Uses batching and concurrency control to handle large datasets efficiently
+     *
+     * @param actionParams - Validated action parameters with entity field mappings
+     * @param contextUser - User context for data access and security
+     * @param executionCount - Current execution count to prevent infinite recursion (max 5)
+     * @returns Promise indicating overall success/failure of the batch
+     */
+    private processAllAccountRecords;
+    /**
+     * Processes account records in concurrent groups to optimize performance
+     * Respects the configured concurrency limit to avoid overwhelming APIs
+     *
+     * @param results - Array of account records to process
+     * @param actionParams - Configuration parameters for enrichment
+     * @param md - Metadata instance for entity operations
+     * @param contextUser - User context for data access
+     */
+    private processAccountGroups;
+    /**
+     * Processes a single domain for both organization and people enrichment
+     * This is the main orchestration method for enriching one account
+     *
+     * @param params - Domain processing parameters with entity configurations
+     * @param startRow - Current row number for progress tracking
+     * @param totalRows - Total number of rows for progress tracking
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure of domain processing
+     */
     protected ProcessSingleDomain(params: ProcessSingleDomainParams, startRow: number, totalRows: number, md: Metadata, currentUser: UserInfo): Promise<boolean>;
-    protected EnrichOrganization(params: ProcessSingleDomainParams, startRow: number, totalRows: number, md: Metadata, currentUser: UserInfo): Promise<boolean>;
+    /**
+     * Enriches organization data using Apollo.io's organization enrichment endpoint
+     * Updates account record with company information and triggers technology processing
+     *
+     * @param params - Domain processing parameters
+     * @param startRow - Current row for progress tracking
+     * @param totalRows - Total rows for progress tracking
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure
+     */
+    private enrichOrganization;
+    /**
+     * Updates an account entity with enriched organization data from Apollo.io
+     * Maps Apollo organization fields to the configured account entity fields
+     *
+     * @param organization - Apollo organization data
+     * @param params - Processing parameters with field mappings
+     * @param record - Current account record data
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating save success/failure
+     */
+    private updateAccountWithOrganizationData;
+    /**
+     * Updates the enrichment timestamp on an account even when no data was found
+     * Prevents repeated attempts to enrich accounts with no Apollo data
+     *
+     * @param params - Processing parameters with field mappings
+     * @param record - Current account record data
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating save success/failure
+     */
+    private updateAccountEnrichedTimestamp;
+    /**
+     * Safely sets a field on an entity if the field name is defined and value is not null
+     * Prevents errors from undefined field mappings
+     *
+     * @param entity - Target entity to update
+     * @param fieldName - Name of the field (can be undefined)
+     * @param value - Value to set (checked for null/undefined)
+     */
+    private setFieldIfExists;
+    /**
+     * Creates or updates technology records associated with an account
+     * Manages the relationship between accounts and their technology stack
+     * Marks old technologies as ended if no longer detected
+     *
+     * @param params - Processing parameters with technology entity configuration
+     * @param accountID - ID of the account to associate technologies with
+     * @param technologies - Array of technology data from Apollo
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating overall success/failure
+     */
     protected CreateAccountTechnologyRecords(params: ProcessSingleDomainParams, accountID: string | number, technologies: TechnologyMap[], md: Metadata, currentUser: UserInfo): Promise<boolean>;
-    protected GetOrCreateTechnologyCategoryId(params: ProcessSingleDomainParams, categoryName: string, md: Metadata, currentUser: UserInfo): Promise<number>;
-    protected GetOrCreateTechnologyId(name: string, categoryId: number, md: Metadata, currentUser: UserInfo): Promise<number>;
-    protected CreateAndEnrichPeople(params: ProcessSingleDomainParams, accountID: string | number, domain: string, startRow: number, md: Metadata, currentUser: UserInfo): Promise<boolean>;
-    protected CreateAndEnrichContact(params: ProcessSingleDomainParams, accountID: string | number, person: SearchPeopleResponsePerson, md: Metadata, currentUser: UserInfo, sequence: number, total: number): Promise<boolean>;
-    protected GetOrCreateContact(params: ProcessSingleDomainParams, accountID: number | string, person: SearchPeopleResponsePerson, md: Metadata, currentUser: UserInfo): Promise<BaseEntity | null>;
-    protected CreateUpdateContactEmploymentAndEducationHistory(params: ProcessSingleDomainParams, contactID: number | string, person: SearchPeopleResponsePerson, md: Metadata, currentUser: UserInfo): Promise<boolean>;
+    /**
+     * Gets or creates a technology category record by name
+     * Ensures technology categories exist before creating technology records
+     *
+     * @param params - Processing parameters with category entity configuration
+     * @param categoryName - Name of the technology category
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<number> - ID of the category (0 if error)
+     */
+    private getOrCreateTechnologyCategoryId;
+    /**
+     * Gets or creates a technology record by name and category
+     * Maintains referential integrity between technologies and categories
+     *
+     * @param name - Name of the technology
+     * @param categoryId - ID of the technology category
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<number> - ID of the technology (0 if error)
+     */
+    private getOrCreateTechnologyId;
+    /**
+     * Searches for and enriches people associated with an organization's domain
+     * Uses Apollo's people search to find contacts at the organization
+     * Handles pagination to retrieve all available contacts (up to configured limit)
+     *
+     * @param params - Processing parameters with contact entity configuration
+     * @param accountID - ID of the account to associate contacts with
+     * @param domain - Organization domain to search for people
+     * @param startRow - Current row for progress tracking
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure of people processing
+     */
+    private createAndEnrichPeople;
+    /**
+     * Determines if a person should be skipped during contact creation
+     * Filters out people with missing data or excluded job titles
+     *
+     * @param person - Person data from Apollo search response
+     * @param domain - Expected domain for email validation
+     * @returns boolean - true if person should be skipped
+     */
+    private shouldSkipPerson;
+    /**
+     * Creates or updates a contact record with enriched data from Apollo
+     * Handles contact deduplication and data validation
+     *
+     * @param params - Processing parameters with contact entity configuration
+     * @param accountID - ID of the account to associate contact with
+     * @param person - Person data from Apollo search response
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @param sequence - Current contact number for progress tracking
+     * @param total - Total contacts for progress tracking
+     * @returns Promise<boolean> indicating success/failure
+     */
+    private createAndEnrichContact;
+    /**
+     * Updates contact entity fields with person data from Apollo
+     * Maps Apollo person fields to the configured contact entity fields
+     *
+     * @param contact - Contact entity to update
+     * @param person - Person data from Apollo
+     * @param CEntity - Contact entity field name mappings
+     */
+    private updateContactFields;
+    /**
+     * Gets an existing contact or creates a new one with conflict detection
+     * Prevents duplicate contacts across different accounts
+     * Supports matching by email or name combination
+     *
+     * @param params - Processing parameters with contact entity configuration
+     * @param accountID - ID of the account to associate contact with
+     * @param person - Person data from Apollo
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<BaseEntity | null> - Contact entity or null if conflict/error
+     */
+    private getOrCreateContact;
+    /**
+     * Creates or updates employment and education history records for a contact
+     * Processes Apollo employment history data to create education records
+     *
+     * @param params - Processing parameters with education entity configuration
+     * @param contactID - ID of the contact to create history for
+     * @param person - Person data containing employment history
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure
+     */
+    private createUpdateContactEmploymentAndEducationHistory;
+    /**
+     * Validates if a date string represents a valid date
+     * Used for employment/education history date validation
+     *
+     * @param dateString - Date string to validate
+     * @returns boolean - true if valid date
+     */
     protected IsValidDate(dateString: string): boolean;
+    /**
+     * Checks if a job title should be excluded from contact creation
+     * Filters out non-business contacts like students and volunteers
+     *
+     * @param title - Job title to check
+     * @returns boolean - true if title should be excluded
+     */
     protected IsExcludedTitle(title: string): boolean;
+    /**
+     * Escapes single quotes in strings for SQL query safety
+     * Prevents SQL injection in dynamic filter construction
+     *
+     * @param str - String to escape
+     * @returns string - Escaped string with doubled single quotes
+     */
     protected EscapeSingleQuotes(str: string): string;
+    /**
+     * Wraps Apollo.io API calls with retry logic for rate limiting
+     * Handles 429 (Too Many Requests) responses with exponential backoff
+     *
+     * @param method - HTTP method ('get' or 'post')
+     * @param endpoint - Apollo API endpoint path
+     * @param data - Request payload for POST requests
+     * @param config - Axios configuration object
+     * @param retryAttempts - Number of retry attempts remaining (default: 1)
+     * @returns Promise<AxiosResponse> - Apollo API response
+     * @throws Error if rate limit exceeded or other API errors
+     */
     protected WrapApolloCall(method: 'get' | 'post', endpoint: string, data: any, config: any, retryAttempts?: number): Promise<AxiosResponse>;
+    /**
+     * Utility method for creating delays in async operations
+     * Used for rate limit backoff and API throttling
+     *
+     * @param ms - Number of milliseconds to wait
+     * @returns Promise that resolves after the specified delay
+     */
     private Timeout;
 }
+/**
+ * Loader function to ensure the ApolloEnrichmentAccountsAction class is included in the bundle
+ * Prevents tree shaking from removing this action class
+ */
 export declare function LoadApolloAccountsEnrichmentAction(): void;
 //# sourceMappingURL=accounts.d.ts.map

package/dist/accounts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../src/accounts.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../src/accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EAAmC,QAAQ,EAAW,QAAQ,EAAgB,MAAM,sBAAsB,CAAC;AAClH,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAoJ,yBAAyB,EAAoF,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACtT,OAAO,EAAe,kBAAkB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAchG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBACa,8BAA+B,SAAQ,UAAU;IAC1D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkE;IAEhG;;;;;;;;;;;OAWG;cACa,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4BvF;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;IAoDpC;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAc9B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;;;OAQG;YACW,wBAAwB;IAoDtC;;;;;;;;OAQG;YACW,oBAAoB;IA6BlC;;;;;;;;;;OAUG;cACa,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAWlK;;;;;;;;;;OAUG;YACW,kBAAkB;IA2ChC;;;;;;;;;;OAUG;YACW,iCAAiC;IAoC/C;;;;;;;;;OASG;YACW,8BAA8B;IAsB5C;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;;;;;;;;OAWG;cACa,8BAA8B,CAAC,MAAM,EAAE,yBAAyB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAiEnM;;;;;;;;;OASG;YACW,+BAA+B;IAwC7C;;;;;;;;;OASG;YACW,uBAAuB;IAoCrC;;;;;;;;;;;;OAYG;YACW,qBAAqB;IAkEnC;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;;;;;;;OAYG;YACW,sBAAsB;IAmCpC;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAgB3B;;;;;;;;;;;OAWG;YACW,kBAAkB;IA6DhC;;;;;;;;;;OAUG;YACW,gDAAgD;IA+D9D;;;;;;OAMG;IACH,SAAS,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAQlD;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOjD;;;;;;OAMG;IACH,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOjD;;;;;;;;;;;OAWG;cACa,cAAc,CAAC,MAAM,EAAE,KAAK,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAE,MAAU,GAAG,OAAO,CAAC,aAAa,CAAC;IAoCnJ;;;;;;OAMG;YACW,OAAO;CAGxB;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,SAEjD"}