Automatically verify insurance coverage for new contracts using Next Insurance, Hippo, Indio, or Vertafore APIs.
Output Generated: Detailed Plan for Automated Insurance Verification System
This initial "AI Generate" step focuses on synthesizing a comprehensive and detailed plan for the automated insurance verification system. Our AI has analyzed the workflow's objectives, potential integration points, and best practices in system design to produce a foundational blueprint.
Key Deliverables from this Step:
This section outlines the proposed architecture and operational flow for the automated insurance verification system.
The system will be designed to initiate verification upon the creation or update of a new contract in your primary contract management system (e.g., CRM, ERP, or a dedicated contract platform).
* Contract ID
* Client Name / Insured Party Name
* Client Contact Information (Email, Phone, Address)
* Effective Date of Contract / Required Coverage Start Date
* Type of Contract (e.g., service agreement, lease, vendor contract)
* Required Coverage Types (e.g., General Liability, Professional Liability, Workers' Comp)
* Minimum Required Coverage Limits
* (Optional) Existing Policy Number (if provided by client)
* (Optional) Insurance Carrier Name (if provided by client)
The core of the automation relies on robust, secure integrations with the specified insurance platforms.
* The system will dynamically determine which API to query based on provided information (e.g., if a specific carrier like Hippo is mentioned, query Hippo directly).
* If no specific carrier is identified, the system will attempt to query multiple APIs in a pre-defined sequence (e.g., based on market share, API reliability, or your preferred providers) to maximize the chances of finding coverage.
* Supported APIs: Next Insurance, Hippo, Indio, Vertafore.
* Future Expansion: The architecture will be modular to allow for easy integration of additional insurance APIs as needed.
* All API integrations will utilize industry-standard secure authentication methods (e.g., OAuth 2.0, API Keys).
* API keys and credentials will be stored securely in an encrypted vault.
* All communications will be over HTTPS to ensure data privacy and integrity.
* An intelligent mapping layer will translate incoming contract data fields into the specific request parameters required by each insurance API.
* This layer will handle data normalization (e.g., address formatting, date formats) to ensure compatibility.
* For instances where an API requires data not directly available, the system will flag these for manual review or attempt to infer based on available data.
* Request Generation: The system will construct API requests based on mapped data, including policyholder details, desired coverage types, and verification scope.
* Response Parsing: Upon receiving a response, the system will parse the JSON/XML payload to extract critical insurance information:
* Policy Number
* Insured Name
* Policy Status (Active, Lapsed, Cancelled, Pending)
* Coverage Start Date
* Coverage End Date
* Specific Coverage Types and Limits (e.g., General Liability: $1M/$2M)
* Named Additional Insureds (if applicable)
* Exclusions or Endorsements (if provided by API)
The system will apply a set of configurable business rules to determine if the retrieved insurance coverage meets the contract's requirements.
* Policy Existence: Is an active policy found for the insured party?
* Insured Name Match: Does the policyholder name match the client name on the contract (allowing for minor variations)?
* Coverage Dates: Does the policy's effective period cover the contract duration?
* Coverage Types: Are all required coverage types (e.g., General Liability, Workers' Comp) present?
* Coverage Limits: Do the policy limits meet or exceed the minimum requirements specified in the contract?
* Policy Status: Is the policy "Active" and not "Lapsed" or "Cancelled"?
* Additional Insured: Is your organization correctly listed as an "Additional Insured" if required by the contract?
* These rules will be configurable, allowing for adjustments based on contract type, risk profile, or evolving compliance needs.
* Verification Outcome:
* Verified: All criteria met.
* Partially Verified: Some criteria met, but minor discrepancies exist (e.g., slightly lower limits, missing an endorsement). Requires manual review.
* Not Verified: Significant discrepancies or no policy found. Requires immediate manual follow-up.
Robust error handling is crucial for a reliable automated system.
* Retry mechanism for transient API errors (e.g., network issues, rate limits).
* Logging of persistent API errors (e.g., invalid credentials, service unavailable).
The results of the verification process need to be clearly communicated and actionable.
* Email/Slack/Teams Alerts: Automated notifications to relevant teams (e.g., Sales, Legal, Compliance) upon verification completion, especially for "Partially Verified" or "Not Verified" outcomes.
* Dashboard/Reporting: A centralized dashboard will provide an overview of verification statuses, pending items, and historical trends.
Upon successful implementation, this workflow will deliver significant benefits:
Following this "AI Generate" step, the workflow will proceed as follows:
To ensure the successful progression of this workflow, we require your input on the following:
We look forward to collaborating with you to bring this automated insurance verification system to fruition.
This deliverable outlines the comprehensive, detailed, and professional output generated by the AI for the "Insurance Verification Workflow". In this step, our AI system processes contract and client data, interacts with specified insurance carrier APIs, and synthesizes the findings into an actionable verification report.
The primary objective of this AI-generated output is to provide a rapid, accurate, and comprehensive assessment of a new contract's insurance coverage, ensuring compliance with contractual requirements and identifying any potential gaps or discrepancies. This automation significantly reduces manual effort, accelerates the contract onboarding process, and mitigates risks associated with inadequate insurance.
The AI system receives the following key data points to initiate the verification process:
* Full Legal Name of Insured Entity
* Business Address
* FEIN/Tax ID (if available and required by API)
* Contact Person (optional, for follow-up)
* Known Policy Numbers
* Insurance Carrier Names (e.g., Next Insurance, Hippo, Indio, Vertafore-supported carriers)
* Certificate of Insurance (COI) document (if available for OCR/data extraction)
The AI employs a sophisticated multi-stage process to generate the verification report:
* Next Insurance API: For policies underwritten or managed by Next Insurance.
* Hippo API: For policies underwritten or managed by Hippo.
* Indio API: For policies managed via the Indio platform (often aggregating multiple carriers).
* Vertafore API: For policies managed through Vertafore systems (e.g., AMS360, Sagitta, ImageRight), allowing access to a broad range of carrier data integrated within their ecosystem.
* Verification of policy existence and active status.
* Detailed coverage types and limits.
* Policy effective and expiration dates.
* Insured entity matching.
* Minimum Coverage Limits: Are the policy limits equal to or greater than the contractual minimums?
* Required Coverage Types: Are all mandatory coverage types present (e.g., General Liability, Professional Liability)?
* Policy Dates: Does the policy cover the entire contract period (or at least the initial phase)?
* Insured Name Matching: Does the policy's insured name precisely match the contracting entity?
The AI system generates a comprehensive "Insurance Verification Report" with the following sections:
* VERIFIED - COMPLIANT: All contractual insurance requirements are met.
* VERIFIED - WITH DISCREPANCIES: Policy found, but some requirements are not met.
* PENDING - INFORMATION REQUIRED: Policy not found or insufficient information to verify.
* FAILED - NO COVERAGE FOUND: No active policy could be identified via specified APIs.
* General Liability: Per Occurrence, General Aggregate, Products-Completed Operations Aggregate, Personal & Advertising Injury.
* Professional Liability/E&O: Per Claim, Aggregate.
* Workers' Compensation: Statutory Limits, Employers Liability (Bodily Injury by Accident, Bodily Injury by Disease).
* Commercial Auto: Combined Single Limit (CSL) or Split Limits (Bodily Injury, Property Damage).
This section directly compares the retrieved policy details against the specific requirements outlined in the new contract.
* Contract Requirement: $1,000,000 Per Occurrence / $2,000,000 Aggregate
* Verified Coverage: $1,000,000 Per Occurrence / $2,000,000 Aggregate
* Compliance: COMPLIANT
* Contract Requirement: $2,000,000 Per Claim
* Verified Coverage: $1,000,000 Per Claim
* Compliance: NON-COMPLIANT (Under-insured)
* Contract Requirement: Statutory Limits
* Verified Coverage: Statutory Limits
* Compliance: COMPLIANT
* Contract Requirement: Policy must cover contract period (e.g., 01/01/2024 - 12/31/2024)
* Verified Policy Dates: 06/01/2024 - 05/31/2025
* Compliance: COMPLIANT (Covers initial period)
This section clearly lists all issues found and provides actionable steps for resolution.
* Recommendation: Contact client immediately to request an increase in Professional Liability limits to meet contractual obligations. Obtain an updated Certificate of Insurance (COI) once revised.
* Recommendation: Flag for proactive follow-up with the client to secure renewal policy information and updated COI well in advance of expiration.
* Recommendation: Urgent follow-up with client to provide proof of Commercial Auto Liability or confirm if vehicles are not used for contract performance. If used, client must obtain this coverage.
* Recommendation: Request client to provide a copy of the endorsement or an updated COI explicitly listing [Your Company Name] as an Additional Insured.
Upon generation of this detailed report (Step 2), the workflow will proceed to Step 3: Human Review & Approval. A designated team member will review the AI-generated report, particularly focusing on any identified discrepancies and recommendations, to make final decisions and initiate follow-up actions with the client as needed.
This document details the professional output for Step 3 of 6: AI Generation within the "Insurance Verification Workflow". The overarching goal of this workflow is to automatically verify insurance coverage for new contracts by leveraging leading insurance platform APIs such as Next Insurance, Hippo, Indio, or Vertafore.
This phase focuses on generating the detailed design and operational blueprint for the AI system that will perform the automated insurance verification. The output here defines the logical flow, components, and anticipated results of the AI's processing.
The primary objective of this AI generation step is to design a robust, intelligent system capable of:
The AI system will follow a multi-stage process, ensuring comprehensive and accurate verification.
* Identify and extract key entities such as:
* Policyholder Name (Company/Individual)
* Contract ID / Reference Number
* Effective Date, Expiration Date
* Required Coverage Types (e.g., General Liability, Professional Liability, Workers' Compensation, Auto)
* Minimum Coverage Limits (e.g., \$1M per occurrence, \$2M aggregate)
* Additional Insured Requirements
* Certificate Holder Information
* Business Industry/Type
* Geographical Scope
* Understand the context and intent of insurance clauses within the contract.
* Example Rules:
* If "Small Business" and "General Liability", prioritize Next Insurance or Hippo.
* If "Commercial Real Estate" and "Property Insurance", prioritize Hippo.
* If "Broker-provided policy details" are present, prioritize Indio or Vertafore for existing policy lookup.
* If no specific provider is indicated, attempt a primary API, then fallback to others.
policyholder_name, business_id, policy_number, coverage_type).* Policy Number
* Insurer Name
* Coverage Status (Active/Inactive)
* Coverage Types and Limits
* Effective and Expiration Dates
* Named Insureds and Additional Insureds
* Exclusions or Special Conditions
* Coverage Type Match: Does the policy cover all required types (e.g., GL, PL, WC)?
* Limit Compliance: Do the policy limits meet or exceed the minimum contract requirements?
* Date Validity: Is the policy active for the entire contract duration?
* Named/Additional Insured Check: Is the correct entity named as the insured or additional insured?
* "Verified - Compliant": All requirements met.
* "Verified - Minor Discrepancies": All critical requirements met, but minor issues (e.g., slightly lower limits, non-critical missing info).
* "Action Required - Major Discrepancies": Critical requirements not met (e.g., missing essential coverage, insufficient limits, incorrect insured).
* "Verification Failed - Unable to Retrieve": API issues, no policy found, or insufficient input data.
* Overall verification status.
* Summary of contract requirements.
* Details of retrieved policy information.
* List of all discrepancies with severity levels.
* Recommendations for next steps (e.g., "Request updated COI," "Contact policyholder for clarification").
* Audit trail of API calls and responses.
Upon completion of the "AI Generation" step, the following will be delivered:
With the detailed AI generation blueprint in place, the workflow will proceed to Step 4: Development & Integration. This phase will involve building the AI system according to this design, integrating with the specified APIs, and developing the verification and reporting modules.
This document details the comprehensive outputs generated by the AI in Step 4 of the "Insurance Verification Workflow." This step is crucial for transforming raw data and API responses into actionable intelligence, ensuring seamless and efficient insurance coverage verification for new contracts.
Workflow Description: Automatically verify insurance coverage for new contracts using Next Insurance, Hippo, Indio, or Vertafore APIs.
Step Description: The AI system will process the data retrieved from the insurance provider APIs and generate detailed, professional, and actionable outputs. This includes structured reports, automated notifications, and audit trails to inform subsequent workflow steps and stakeholders.
In this critical phase, our AI system takes the raw, often disparate, data obtained from the Next Insurance, Hippo, Indio, or Vertafore APIs and transforms it into highly structured, human-readable, and machine-consumable outputs. This generation process is designed to provide immediate clarity on insurance coverage status, identify any discrepancies, and trigger necessary downstream actions, significantly enhancing efficiency and accuracy.
The AI will generate the following key outputs, each tailored to specific needs within your organization:
This is the primary deliverable, providing a clear, concise, and detailed summary of the insurance coverage status for each new contract.
* Contract/Client ID: Unique identifier for the contract undergoing verification.
* Policy Holder Information: Full legal name, address, and contact details of the insured entity.
* Insurer Details: Name of the insurance provider (e.g., Next Insurance, Hippo, etc.), policy issuer, and contact information.
* Policy Number(s): All relevant policy numbers identified.
* Verification Status:
* VERIFIED: Coverage confirmed and meets all specified requirements.
* PENDING: Verification is in progress, awaiting further data or manual review.
* NOT FOUND: Policy could not be located with the provided details.
* INSUFFICIENT COVERAGE: Policy found, but coverage limits or types do not meet contract requirements.
* EXPIRED/INVALID: Policy is no longer active or is deemed invalid.
* Policy Effective & Expiration Dates: Crucial for ongoing compliance.
* Coverage Types & Limits: Detailed breakdown of all applicable coverage (e.g., General Liability, Professional Liability, Workers' Compensation) and their respective limits.
* Deductibles: Any applicable deductible amounts.
* Additional Insured Status: Confirmation if your organization is listed as an additional insured.
* Verification Timestamp: Date and time the verification was performed.
* API Response Reference: A link or reference to the raw API data for audit purposes.
The AI generates targeted alerts to inform relevant stakeholders immediately about critical verification outcomes.
* Verification Success Notification: An automated email or internal message (e.g., Slack, Teams integration) to the sales, legal, or onboarding team confirming successful verification.
Content:* Contract ID, Policy Holder, Verification Status: VERIFIED, Link to full IVR.
* Verification Failure/Pending Alert: Immediate notification for cases where verification fails or requires attention.
Content:* Contract ID, Policy Holder, Verification Status (e.g., NOT FOUND, INSUFFICIENT COVERAGE, PENDING), specific reason for failure/pending status, and suggested next steps (e.g., "Contact client for updated policy details," "Review coverage requirements").
Delivery:* Prioritized email, internal messaging, or direct update to CRM/ERP system.
* Upcoming Expiration Reminders (Optional): If configured, the AI can track verified policies and generate alerts for policies nearing their expiration date.
Content:* Contract ID, Policy Holder, Policy Expiration Date, Days remaining until expiration.
Delivery:* Scheduled email or internal message to ensure proactive renewal management.
When the verification process encounters issues due to incomplete or inconsistent input data, the AI will generate a specific report.
* Contract/Client ID: Identifier for the affected contract.
* Identified Discrepancy: Specific data fields that are missing, malformed, or inconsistent (e.g., "Policy Number is invalid format," "Client Address missing street number," "Insured Name does not match contract").
* Impact: Explanation of how the discrepancy affected the verification attempt.
* Recommended Action: Clear instructions on how to rectify the issue (e.g., "Request updated policy details from client," "Verify client address in CRM").
Every verification attempt, regardless of outcome, is meticulously logged by the AI.
* Full API Request Payload: The exact data sent to the insurance API.
* Full API Response: The complete, raw response received from the insurance API.
* Verification Outcome: The final status determined by the AI (VERIFIED, NOT FOUND, etc.).
* Timestamp: Date and time of the API interaction.
* System User/Initiator: Identifies the system or user that triggered the verification.
* Error Messages: Any specific error messages from the API or the AI's processing logic.
The AI's generation capabilities are powered by sophisticated mechanisms:
The AI-generated outputs can be seamlessly integrated into your existing technology stack through:
Upon completion of this step, the generated outputs will be ready for review and integration. We recommend the following:
This AI-driven generation capability ensures that your insurance verification process is not only automated but also intelligent, providing clear, actionable insights directly to where they are needed most.
Workflow Title: Automated Insurance Verification for New Contracts
Workflow Description: Automatically verify insurance coverage for new contracts using Next Insurance, Hippo, Indio, or Vertafore APIs.
This document provides a comprehensive overview of the "Automated Insurance Verification for New Contracts" workflow. Designed to streamline and enhance the efficiency of your contract management process, this workflow leverages advanced AI and API integrations to automatically validate insurance coverage for new contracts. By integrating with leading insurance platforms such as Next Insurance, Hippo, Indio, and Vertafore, the system ensures that all incoming contracts meet specified insurance requirements promptly and accurately, significantly reducing manual effort and minimizing compliance risks.
The primary objective of this workflow is to:
This workflow is meticulously designed across six key steps to ensure robust and reliable insurance verification.
Description: This initial step focuses on securely and efficiently bringing new contract data into the verification system.
* CRM Integration: Automatic ingestion of new contract records from your CRM (e.g., Salesforce, HubSpot) upon contract status update (e.g., "Signed", "Approved").
* Email Monitoring: Dedicated inbox monitored for new contract attachments (PDF, DOCX) from specific senders or with specific subject lines.
* Document Upload Portal: Secure web portal for manual upload of contract documents by authorized personnel.
* API Endpoint: Direct programmatic submission of structured contract data via a dedicated API.
* Optical Character Recognition (OCR): For scanned documents or PDFs, OCR will convert image-based text into machine-readable format.
* Natural Language Processing (NLP): Initial parsing of contract documents to identify key sections and potential data points for later extraction.
Description: Once a contract is ingested, critical customer and contract-specific information is extracted to facilitate the insurance verification process.
* Customer Name/Entity: Full legal name of the contracting party.
* Contract ID/Reference: Unique identifier for the contract.
* Contract Effective Date: The date from which the contract terms are active.
* Required Coverage Types: Specific types of insurance mandated by the contract (e.g., General Liability, Professional Liability, Workers' Compensation, Auto Liability).
* Minimum Coverage Limits: Monetary thresholds for each required coverage type.
* Additional Insured Requirements: Parties required to be named as additional insureds.
* Policy Holder Information (if available): Existing policy numbers or known insurance providers from the contract.
* AI/ML-powered Document Understanding: Utilizes pre-trained models and custom rules to accurately locate and extract structured and unstructured data from contract clauses.
* Template Matching: For standardized contract templates, pre-defined extraction zones can be used.
* Human-in-the-Loop (Optional): For complex or non-standard contracts, a human review step can be triggered to validate extracted data, ensuring maximum accuracy.
Description: This step determines which insurance provider(s) are relevant to the customer and the verification process.
* Internal Customer Database: Cross-reference extracted customer data with your existing customer records to identify known insurance providers or policies.
* Primary Provider Check: If the contract specifies a particular insurer, prioritize checking that provider's API first.
* Sequential API Query (Fallback): If no specific provider is identified or if the initial check fails, the system will query the integrated APIs (Next Insurance, Hippo, Indio, Vertafore) in a pre-defined or intelligent sequence.
* Smart Routing: Based on customer industry, location, or contract type, the system may intelligently prioritize certain providers (e.g., Hippo for home/residential, Next for small business).
Description: This is the core step where the system interacts with external insurance platforms to retrieve actual policy details.
* Customer Identifier: Use extracted customer names, IDs, or email addresses to search for existing policies.
* Policy Number (if available): Direct query using a known policy number for faster retrieval.
* Date Range: Specify the contract effective date to ensure active policy retrieval.
* Fetch policy details including: policy number, effective dates, expiration dates, coverage types, coverage limits, deductibles, named insureds, and additional insured endorsements.
* Error Handling: Implement robust error handling for API timeouts, rate limits, invalid credentials, or "policy not found" responses. Retry mechanisms and fallback strategies will be in place.
Description: The retrieved insurance data is meticulously compared against the contract's required coverage to determine compliance.
* Coverage Type Matching: Verify that all required coverage types (e.g., General Liability) are present in the retrieved policies.
* Limit Comparison: Compare the actual coverage limits against the minimum limits specified in the contract.
* Effective Date Check: Ensure the policy effective dates cover the contract's duration (or at least its start date).
* Expiration Date Monitoring: Flag policies nearing expiration or already expired relative to the contract term.
* Additional Insured Verification: Confirm that your organization (or other specified parties) is named as an additional insured, if required by the contract.
* Exclusion Review (Basic): Perform a basic check for major exclusions that might invalidate coverage for the contract's scope.
Description: The final step involves generating comprehensive reports and notifying relevant stakeholders about the verification outcome.
* Summary: Clear "Pass" or "Fail" status.
* Details: Breakdown of each required coverage type, actual vs. required limits, policy effective/expiration dates, and additional insured status.
* Discrepancy Highlight: Clearly mark any areas of non-compliance or gaps.
* Audit Trail: Include timestamps, user actions (if any), and source data references.
* Success Notification: For "Pass" outcomes, inform relevant teams (e.g., Sales, Contract Management) that the contract is clear for activation.
* Failure/Alert Notification: For "Fail" or "Pending" outcomes, send immediate alerts to designated personnel (e.g., Legal, Risk Management, Account Manager) with details of the non-compliance.
* Escalation Matrix: Implement an escalation path for unaddressed alerts or critical coverage deficiencies.
* CRM Update: Update the contract record in the CRM with the insurance verification status.
* Document Archiving: Store the verification report and relevant policy documents in your central document management system.
* Dashboard Integration: Populate a real-time dashboard for an overview of all contract verification statuses.
Implementing this workflow will yield significant benefits for your organization:
To successfully implement this workflow, the following technical considerations and requirements should be addressed:
Potential future enhancements to further optimize this workflow include:
This "Automated Insurance Verification for New Contracts" workflow represents a significant leap forward in optimizing your contract management and risk mitigation strategies. By leveraging state-of-the-art AI and robust API integrations, you can ensure comprehensive, accurate, and rapid insurance compliance for every new contract.
Next Steps:
Deliverable: Comprehensive Workflow Output
This document outlines the detailed professional output for the "Insurance Verification Workflow," an automated system designed to streamline and enhance the process of verifying insurance coverage for new contracts. By leveraging advanced API integrations with leading insurance platforms, this workflow ensures accuracy, efficiency, and compliance, significantly reducing manual effort and accelerating contract finalization.
The "Insurance Verification Workflow" automates the critical task of confirming insurance coverage for all new contracts. This system integrates seamlessly with Next Insurance, Hippo, Indio, and Vertafore APIs to query, validate, and record policy details in real-time. The primary goal is to eliminate manual verification bottlenecks, reduce human error, and provide immediate visibility into a contract's insurance status, thereby accelerating the contract lifecycle and minimizing risk.
This workflow is triggered upon the creation or submission of a new contract requiring insurance verification. It intelligently routes verification requests to the appropriate insurance API based on predefined criteria (e.g., type of insurance, client profile, policy details). The system then processes the API response, extracts relevant coverage information, updates the contract status, and notifies stakeholders of the verification outcome.
Key Objectives:
The workflow leverages specific APIs to cater to a broad spectrum of insurance verification needs:
* Extracts business name, policy number, and relevant contract details from the new contract.
* Initiates an API call to Next Insurance to query policy status, coverage limits, effective/expiration dates, and insured party details.
* Verifies if the policy is active and if coverage meets contractual minimums.
* Extracts property address, policyholder name, and relevant property-related contract details.
* Makes an API call to Hippo to confirm policy existence, coverage for the specified property, policy status, and deductible information.
* Ensures the property is insured as required by the contract (e.g., for real estate transactions, property management agreements).
* Submits contract-related data (e.g., client name, policy type, desired coverage details) to Indio.
* Indio's API connects to the relevant carrier or broker system to retrieve detailed policy information, binding status, and potentially even insurance certificates.
* Confirms policy binding, coverage details, and ensures all required documentation is available.
* Queries Vertafore's APIs with client/policy information to access existing policy data within the agency's system.
* Retrieves policy details, coverage summaries, endorsements, and potentially claims history.
* Validates the existence and specifics of policies held by the client through their Vertafore-using agency.
* Is the policy active?
* Does coverage meet minimum limits?
* Are the correct parties insured?
* Are there any critical exclusions?
* If "Verified," a confirmation notification is sent.
* If "Insufficient Coverage" or "Verification Failed," an alert is sent to the responsible team (e.g., sales, legal) for review and action.
Implementing the "Insurance Verification Workflow" delivers significant strategic and operational advantages:
To fully implement and leverage the "Insurance Verification Workflow," the following steps are typically involved:
The "Insurance Verification Workflow" represents a significant leap forward in automating and securing your contract lifecycle. By integrating with leading insurance platforms, it guarantees that every new contract is thoroughly vetted for insurance compliance, providing peace of mind and operational excellence. We are committed to supporting you through every stage of implementation to ensure a seamless and successful deployment.