AGENT SKILL

guidewire-core-workflow-b

Execute Guidewire secondary workflow: Claims processing in ClaimCenter. Use when implementing FNOL, claim investigation, reserves, payments, and settlement. Trigger with phrases like "claimcenter workflow", "create claim", "file fnol", "process claim", "claim settlement", "claim payment".

License 许可
MIT
最近更新
2026-11-15
Stars
★ 2.0k
Forks
233

01 前言 Front Matter

name
guidewire-core-workflow-b
author
Jeremy Longshore <jeremy@intentsolutions.io>
license
MIT
version
1.0.0
description
Execute Guidewire secondary workflow: Claims processing in ClaimCenter. Use when implementing FNOL, claim investigation, reserves, payments, and settlement. Trigger with phrases like "claimcenter workflow", "create claim", "file fnol", "process claim", "claim settlement", "claim payment".
allowed-tools
Read, Write, Edit, Bash(curl:*), Bash(npm:*), Grep

03 SKILL.md 正文

Guidewire Core Workflow B: Claims Processing

Overview

Master the complete claims lifecycle in ClaimCenter: First Notice of Loss (FNOL), claim investigation, reserve setting, payments, and settlement.

Prerequisites

  • Completed guidewire-install-auth and guidewire-core-workflow-a
  • Understanding of claims handling processes
  • Valid API credentials with claims admin permissions

Claims Lifecycle States

FNOL → Open → Investigation → Evaluation → Negotiation → Settlement → Closed
  |      |          |              |             |            |          |
  v      v          v              v             v            v          v
[Draft] [Open]  [Reserve]    [Exposure]   [Payment]   [Settle]   [Closed]

Instructions

Step 1: Create FNOL (First Notice of Loss)

// Create a new claim via FNOL
interface FNOLRequest {
  data: {
    attributes: {
      lossDate: string;
      lossTime?: string;
      reportedDate: string;
      lossType: { code: string };
      lossCause: { code: string };
      description: string;
      policyNumber: string;
      lossLocation?: {
        addressLine1: string;
        city: string;
        state: { code: string };
        postalCode: string;
      };
      reporter?: {
        firstName: string;
        lastName: string;
        primaryPhone: string;
        relationship: { code: string };
      };
    };
  };
}

async function createFNOL(fnolData: FNOLData): Promise<Claim> {
  const request: FNOLRequest = {
    data: {
      attributes: {
        lossDate: fnolData.lossDate,
        lossTime: fnolData.lossTime,
        reportedDate: new Date().toISOString().split('T')[0],
        lossType: { code: fnolData.lossType }, // 'AUTO', 'PR', 'GL', 'WC'
        lossCause: { code: fnolData.lossCause },
        description: fnolData.description,
        policyNumber: fnolData.policyNumber,
        lossLocation: {
          addressLine1: fnolData.location.address,
          city: fnolData.location.city,
          state: { code: fnolData.location.state },
          postalCode: fnolData.location.zip
        },
        reporter: {
          firstName: fnolData.reporter.firstName,
          lastName: fnolData.reporter.lastName,
          primaryPhone: fnolData.reporter.phone,
          relationship: { code: 'insured' }
        }
      }
    }
  };

  const response = await claimCenterClient.request<{ data: Claim }>(
    'POST',
    '/fnol/v1/fnol',
    request
  );

  console.log(`Created claim: ${response.data.claimNumber}`);
  return response.data;
}

Step 2: Add Exposures

// Add exposures (coverages that may apply)
interface ExposureRequest {
  data: {
    attributes: {
      exposureType: { code: string };
      lossParty: { code: string };
      primaryCoverage: { code: string };
      claimant?: { id: string };
      incident?: { id: string };
    };
  };
}

async function addExposure(
  claimId: string,
  exposureData: ExposureData
): Promise<Exposure> {
  const request: ExposureRequest = {
    data: {
      attributes: {
        exposureType: { code: exposureData.type }, // 'VehicleDamage', 'BodilyInjury', etc.
        lossParty: { code: exposureData.lossParty }, // 'insured', 'claimant'
        primaryCoverage: { code: exposureData.coverageCode },
        claimant: exposureData.claimantId ? { id: exposureData.claimantId } : undefined
      }
    }
  };

  const response = await claimCenterClient.request<{ data: Exposure }>(
    'POST',
    `/claim/v1/claims/${claimId}/exposures`,
    request
  );

  return response.data;
}

Step 3: Add Incidents

// Add vehicle incident for auto claims
interface VehicleIncidentRequest {
  data: {
    attributes: {
      severity: { code: string };
      description: string;
      vehicle: {
        vin?: string;
        year: number;
        make: string;
        model: string;
        color?: string;
        licensePlate?: string;
      };
      damageDescription: string;
      airbagDeployed?: boolean;
      vehicleOperable?: boolean;
    };
  };
}

async function addVehicleIncident(
  claimId: string,
  vehicleData: VehicleIncidentData
): Promise<VehicleIncident> {
  const request: VehicleIncidentRequest = {
    data: {
      attributes: {
        severity: { code: vehicleData.severity }, // 'minor', 'moderate', 'major', 'total-loss'
        description: vehicleData.description,
        vehicle: {
          vin: vehicleData.vin,
          year: vehicleData.year,
          make: vehicleData.make,
          model: vehicleData.model,
          licensePlate: vehicleData.licensePlate
        },
        damageDescription: vehicleData.damageDescription,
        airbagDeployed: vehicleData.airbagDeployed,
        vehicleOperable: vehicleData.vehicleOperable
      }
    }
  };

  const response = await claimCenterClient.request<{ data: VehicleIncident }>(
    'POST',
    `/claim/v1/claims/${claimId}/vehicle-incidents`,
    request
  );

  return response.data;
}

Step 4: Set Reserves

// Set reserve on exposure
interface ReserveRequest {
  data: {
    attributes: {
      reserveLine: { code: string };
      costType: { code: string };
      costCategory: { code: string };
      newAmount: { amount: number; currency: string };
      comments: string;
    };
  };
}

async function setReserve(
  claimId: string,
  exposureId: string,
  reserveData: ReserveData
): Promise<Reserve> {
  const request: ReserveRequest = {
    data: {
      attributes: {
        reserveLine: { code: reserveData.reserveLine }, // 'indemnity', 'expenses'
        costType: { code: reserveData.costType },
        costCategory: { code: reserveData.costCategory },
        newAmount: {
          amount: reserveData.amount,
          currency: 'usd'
        },
        comments: reserveData.comments
      }
    }
  };

  const response = await claimCenterClient.request<{ data: Reserve }>(
    'POST',
    `/claim/v1/claims/${claimId}/exposures/${exposureId}/reserves`,
    request
  );

  console.log(`Set reserve: $${reserveData.amount} on exposure ${exposureId}`);
  return response.data;
}

Step 5: Create Payment

// Create claim payment
interface PaymentRequest {
  data: {
    attributes: {
      paymentType: { code: string };
      exposure: { id: string };
      payee: {
        payeeType: { code: string };
        claimContact?: { id: string };
        payeeName?: string;
      };
      reserveLine: { code: string };
      costType: { code: string };
      costCategory: { code: string };
      amount: { amount: number; currency: string };
      comments?: string;
      paymentMethod?: { code: string };
    };
  };
}

async function createPayment(
  claimId: string,
  paymentData: PaymentData
): Promise<Payment> {
  const request: PaymentRequest = {
    data: {
      attributes: {
        paymentType: { code: paymentData.paymentType }, // 'partial', 'final'
        exposure: { id: paymentData.exposureId },
        payee: {
          payeeType: { code: paymentData.payeeType },
          claimContact: paymentData.claimContactId
            ? { id: paymentData.claimContactId }
            : undefined
        },
        reserveLine: { code: 'indemnity' },
        costType: { code: paymentData.costType },
        costCategory: { code: paymentData.costCategory },
        amount: { amount: paymentData.amount, currency: 'usd' },
        comments: paymentData.comments,
        paymentMethod: { code: paymentData.method || 'check' }
      }
    }
  };

  const response = await claimCenterClient.request<{ data: Payment }>(
    'POST',
    `/claim/v1/claims/${claimId}/payments`,
    request
  );

  console.log(`Created payment: $${paymentData.amount} - Check #${response.data.checkNumber}`);
  return response.data;
}

Step 6: Close Exposure

// Close exposure after settlement
async function closeExposure(
  claimId: string,
  exposureId: string,
  outcome: string
): Promise<Exposure> {
  const response = await claimCenterClient.request<{ data: Exposure }>(
    'POST',
    `/claim/v1/claims/${claimId}/exposures/${exposureId}/close`,
    {
      data: {
        attributes: {
          closedOutcome: { code: outcome } // 'completed', 'denied', 'duplicate'
        }
      }
    }
  );

  return response.data;
}

Step 7: Close Claim

// Close claim when all exposures are closed
async function closeClaim(claimId: string): Promise<Claim> {
  const response = await claimCenterClient.request<{ data: Claim }>(
    'POST',
    `/claim/v1/claims/${claimId}/close`,
    {
      data: {
        attributes: {
          closedOutcome: { code: 'completed' }
        }
      }
    }
  );

  console.log(`Closed claim: ${response.data.claimNumber}`);
  return response.data;
}

Gosu Implementation

// Complete claims workflow in Gosu
package gw.custom.claim

uses gw.api.util.Logger
uses gw.cc.claim.Claim
uses gw.cc.exposure.Exposure
uses gw.transaction.Transaction

class ClaimWorkflow {
  private static final var LOG = Logger.forCategory("ClaimWorkflow")

  static function createClaim(
    policyNumber : String,
    lossDate : Date,
    lossType : LossType,
    description : String
  ) : Claim {

    return Transaction.runWithNewBundle(\bundle -> {
      // Find policy
      var policy = findPolicy(policyNumber)
      if (policy == null) {
        throw new IllegalArgumentException("Policy not found: ${policyNumber}")
      }

      // Create claim
      var claim = new Claim(bundle)
      claim.Policy = policy
      claim.LossDate = lossDate
      claim.LossType = lossType
      claim.Description = description
      claim.ReportedDate = Date.Today
      claim.LossCause = LossCause.TC_VEHCOLLISION

      // Set claim to open
      claim.open()

      LOG.info("Created claim: ${claim.ClaimNumber}")
      return claim
    })
  }

  static function addVehicleExposure(
    claim : Claim,
    vehicle : Vehicle,
    coverageCode : String
  ) : Exposure {

    return Transaction.runWithNewBundle(\bundle -> {
      var claim = bundle.add(claim)

      // Create vehicle incident
      var incident = new VehicleIncident(bundle)
      incident.Claim = claim
      incident.Vehicle = vehicle
      incident.Description = "Vehicle damage from ${claim.LossCause.DisplayName}"

      // Create exposure
      var exposure = new Exposure(bundle)
      exposure.Claim = claim
      exposure.ExposureType = ExposureType.TC_VEHICLEDAMAGE
      exposure.LossParty = LossPartyType.TC_INSURED
      exposure.PrimaryCoverage = CoverageType.get(coverageCode)
      exposure.VehicleIncident = incident

      LOG.info("Created exposure: ${exposure.ExposureType.DisplayName}")
      return exposure
    })
  }

  static function setExposureReserve(
    exposure : Exposure,
    amount : java.math.BigDecimal,
    reserveLine : ReserveLine
  ) {
    Transaction.runWithNewBundle(\bundle -> {
      var exp = bundle.add(exposure)

      var reserve = new Reserve(bundle)
      reserve.Exposure = exp
      reserve.ReserveLine = reserveLine
      reserve.CostType = CostType.TC_CLAIMCOST
      reserve.CostCategory = CostCategory.TC_BODY
      reserve.NewAmount = new gw.api.financials.CurrencyAmount(amount, Currency.TC_USD)
      reserve.Comments = "Initial reserve set"

      LOG.info("Set reserve: ${amount} on ${exp.ExposureType.DisplayName}")
    })
  }

  static function createPayment(
    exposure : Exposure,
    amount : java.math.BigDecimal,
    payee : Contact,
    paymentType : PaymentType
  ) : Payment {

    return Transaction.runWithNewBundle(\bundle -> {
      var exp = bundle.add(exposure)

      var payment = new Payment(bundle)
      payment.Exposure = exp
      payment.Claim = exp.Claim
      payment.PaymentType = paymentType
      payment.ReserveLine = ReserveLine.TC_INDEMNITY
      payment.CostType = CostType.TC_CLAIMCOST
      payment.CostCategory = CostCategory.TC_BODY
      payment.Payee = payee
      payment.GrossAmount = new gw.api.financials.CurrencyAmount(amount, Currency.TC_USD)

      // Submit for approval
      payment.submit()

      LOG.info("Created payment: ${amount} to ${payee.DisplayName}")
      return payment
    })
  }

  static function closeClaim(claim : Claim, outcome : CloseOutcome) {
    Transaction.runWithNewBundle(\bundle -> {
      var c = bundle.add(claim)

      // Close all open exposures first
      c.Exposures
        .where(\e -> e.State == ExposureState.TC_OPEN)
        .each(\e -> {
          e.close(outcome)
        })

      // Close claim
      c.close(outcome)
      LOG.info("Closed claim: ${c.ClaimNumber}")
    })
  }
}

Output

  • FNOL claim with claim number
  • Exposures linked to coverages
  • Reserves set on exposures
  • Payments processed
  • Claim closed with outcome

Error Handling

Error Cause Solution
Policy not found Invalid policy number Verify policy number and status
Coverage not applicable Wrong coverage type Check policy coverages
Reserve exceeds limit Over policy limit Adjust to policy limits
Payment validation Missing required fields Check payee and amount
Cannot close Open activities/exposures Complete pending items

Claim Types and Loss Causes

// Common loss types
const lossTypes = {
  AUTO: ['vehcollision', 'vehglass', 'vehtheft', 'vehvandalism'],
  PROPERTY: ['fire', 'water', 'theft', 'weather'],
  LIABILITY: ['bodily_injury', 'property_damage', 'personal_injury'],
  WORKERS_COMP: ['injury', 'illness', 'death']
};

// Map loss cause to exposures
function getDefaultExposures(lossType: string, lossCause: string): string[] {
  if (lossType === 'AUTO' && lossCause === 'vehcollision') {
    return ['VehicleDamage', 'BodilyInjury', 'PropertyDamage'];
  }
  // Additional mappings...
  return [];
}

Resources

Next Steps

For error handling patterns, see guidewire-common-errors.

04 同仓库更多 Skills

Dicklesworthstone
Dicklesworthstone/pi_agent_rust

theme-factory

Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.

视觉设计
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

web-artifacts-builder

Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.

前端开发
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

webapp-testing

Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

测试与质量前端开发
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

neuropixels-analysis

Neuropixels neural recording analysis. Load SpikeGLX/OpenEphys data, preprocess, motion correction, Kilosort4 spike sorting, quality metrics, Allen/IBL curation, AI-assisted visual analysis, for Neuropixels 1.0/2.0 extracellular electrophysiology. Use when working with neural recordings, spike sorting, extracellular electrophysiology, or when the user mentions Neuropixels, SpikeGLX, Open Ephys, Kilosort, quality metrics, or unit curation.

★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

skill-creator

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Skill与智能体开发
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

notebooklm

Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automation, library management, persistent auth. Drastically reduced hallucinations through document-only responses.

Skill与智能体开发
★ 2.0k