export type LeaveProgramContractVersion = 'company_leave_program.v1';
export type ProgramKind = 'COMPANY_POLICY';
export interface LeaveProgramJurisdiction {
    country: string;
    subdivisions?: string[];
}
export interface Duration {
    kind: 'duration';
    amount: number;
    unit: 'HOURS' | 'DAYS' | 'WEEKS';
}
export interface MoneyAmount {
    kind: 'money_amount';
    amount: string;
    currency: string;
}
export interface PercentOfPay {
    kind: 'percent_of_pay';
    percent: number;
}
export interface FactRef {
    kind: 'fact_ref';
    path: string;
}
export interface WageReplacementRef {
    kind: 'wage_replacement_ref';
    programCodes: string[];
}
export interface EvidenceRequirement {
    key: string;
    message?: string;
}
export type PolicyCondition = {
    type: 'employee_country_is';
    country: string;
} | {
    type: 'leave_reason_is_parental';
} | {
    type: 'leave_reason_in';
    values: string[];
} | {
    type: 'tenure_months_match';
    asOf: FactRef;
    tiers: TenureMatchTier[];
} | {
    type: 'advanced_predicate';
    name: string;
    uses: FactRef[];
};
export interface TenureMatchTier {
    gte?: number;
    lt?: number;
    value: Duration;
}
export type DurationExpression = Duration | {
    type: 'parental_relationship_duration';
    cases: Partial<Record<ParentalRelationship, Duration>>;
    unknown?: EvidenceRequirement;
} | {
    type: 'tenure_months_duration';
    tiers: TenureMatchTier[];
} | {
    type: 'advanced_duration_formula';
    name: string;
    uses: FactRef[];
};
export type ParentalRelationship = 'birthingParent' | 'nonBirthingParent' | 'adoptionParent' | 'fosterParent' | 'supportingPerson';
export type PayDecision = {
    type: 'NO_COMPANY_PAY';
} | {
    type: 'FIXED_AMOUNT';
    amount: MoneyAmount;
    duration: DurationExpression;
    earningType: string;
} | {
    type: 'PERCENT_OF_PAY';
    target: PercentOfPay;
    base: FactRef;
    duration: DurationExpression;
    earningType: string;
} | {
    type: 'MAKE_WHOLE_TOPUP';
    target: PercentOfPay;
    base: FactRef;
    offsetBy: WageReplacementRef;
    earningType: string;
};
export interface EntitlementDecision {
    type: 'PAID_LEAVE';
    duration: DurationExpression;
    leaveType?: string;
}
export interface RequirementDecision {
    type: 'ADMIN_TASK';
    key: string;
    blocksPayment: boolean;
}
export interface LeaveProgramDiagnostic {
    code: string;
    message: string;
}
export type AdvancedCapability = 'CUSTOM_ELIGIBILITY_PREDICATE' | 'CUSTOM_DURATION_FORMULA' | 'CUSTOM_PAY_FORMULA';
export interface CompanyLeaveProgramResult {
    contractVersion: LeaveProgramContractVersion;
    program: {
        code: string;
        displayName: string;
        description?: string;
        programKind: ProgramKind;
        jurisdiction: LeaveProgramJurisdiction;
        dependsOn: string[];
        capabilities: AdvancedCapability[];
    };
    appliesTo: PolicyCondition[];
    eligibility: {
        conditions: PolicyCondition[];
        requiredEvidence: EvidenceRequirement[];
    };
    entitlement?: EntitlementDecision;
    pay: PayDecision;
    requirements: RequirementDecision[];
    jobProtection: 'NONE' | 'UNCHANGED';
    diagnostics: LeaveProgramDiagnostic[];
}
export interface CompanyLeaveProgramDefinition {
    readonly contractVersion: LeaveProgramContractVersion;
    readonly code: string;
    readonly displayName: string;
    readonly jurisdiction: LeaveProgramJurisdiction;
    readonly dependsOn: string[];
    toResult(context?: CompanyLeaveProgramContext): CompanyLeaveProgramResult;
}
export interface CompanyLeaveProgramDefinitionConfig {
    code: string;
    displayName: string;
    description?: string;
    jurisdiction: LeaveProgramJurisdiction;
    programKind?: ProgramKind;
    dependsOn?: string[];
    capabilities?: AdvancedCapability[];
    appliesTo?: (context: CompanyLeaveProgramContext) => PolicyCondition | PolicyCondition[];
    evaluate: (context: CompanyLeaveProgramContext) => PolicyBuilderResult;
}
export interface PolicyBuilderResult {
    conditions: PolicyCondition[];
    requiredEvidence: EvidenceRequirement[];
    entitlement?: EntitlementDecision;
    pay: PayDecision;
    requirements: RequirementDecision[];
    jobProtection: 'NONE' | 'UNCHANGED';
    diagnostics: LeaveProgramDiagnostic[];
}
export interface CompanyLeaveProgramContext {
    employee: {
        country: {
            is(country: string): PolicyCondition;
        };
        tenure: {
            monthsAt(asOf: FactRef): {
                match(tiers: TenureMatchTier[]): DurationExpression;
            };
        };
    };
    leave: {
        reason: {
            isParental(): PolicyCondition;
            isOneOf(values: string[]): PolicyCondition;
        };
        startDate: FactRef;
        parentalRelationship: {
            match(cases: Partial<Record<ParentalRelationship | 'unknown', Duration | EvidenceRequirement>>): DurationExpression;
        };
    };
    pay: {
        contractualWeeklyPay: FactRef;
    };
    programs: {
        wageReplacement(programCodes: string[]): WageReplacementRef;
    };
    evidence: {
        require(key: string, message?: string): EvidenceRequirement;
    };
    policy(): PolicyBuilder;
}
export interface TopUpToOptions {
    base: FactRef;
    offsetBy: WageReplacementRef;
    earningType: string;
}
export interface PayPercentOfPayOptions {
    base: FactRef;
    duration: DurationExpression;
    earningType: string;
}
export interface PayFixedAmountOptions {
    duration: DurationExpression;
    earningType: string;
}
export interface GrantPaidLeaveOptions {
    leaveType?: string;
}
export interface RequireKnownOptions {
    evidenceKey: string;
    message?: string;
}
export interface PolicyBuilder {
    eligibleWhen(condition: PolicyCondition): PolicyBuilder;
    requireKnown(fact: FactRef | WageReplacementRef, options: RequireKnownOptions): PolicyBuilder;
    grantPaidLeave(duration: DurationExpression, options?: GrantPaidLeaveOptions): PolicyBuilder;
    noCompanyPay(): PolicyBuilder;
    payFixedAmount(amount: MoneyAmount, options: PayFixedAmountOptions): PolicyBuilder;
    payPercentOfPay(target: PercentOfPay, options: PayPercentOfPayOptions): PolicyBuilder;
    topUpTo(target: PercentOfPay, options: TopUpToOptions): PolicyBuilder;
    requireAdminTask(key: AdminTask | string): PolicyBuilder;
    doesNotProvideJobProtection(): PolicyBuilder;
    build(): PolicyBuilderResult;
}
export declare enum AdminTask {
    ManagerAcknowledgement = "manager_acknowledgement",
    PaymentRecordReconciliation = "payment_record_reconciliation",
    SeparateFromJobProtection = "separate_from_job_protection"
}
//# sourceMappingURL=types.d.ts.map