@socotra/ec-react-schemas 2.26.1-next.0 → 2.26.1-next.10

package/dist/index.d.ts

@@ -460,8 +460,8 @@ export declare const AddTaskRequestBffSchema: z.ZodObject<{
         contents: z.ZodString;
     }, z.core.$strip>>;
     userAssignment: z.ZodOptional<z.ZodObject<{
-        userLocator: z.ZodGUID;
         userAssociationRole: z.ZodString;
+        userLocator: z.ZodGUID;
     }, z.core.$strip>>;
     deadlineTime: z.ZodISODateTime;
     references: z.ZodArray<z.ZodObject<{
@@ -1104,6 +1104,136 @@ export declare const BasePolicyTransactionResponseSchema: z.ZodObject<{
     }>;
 }, z.core.$strip>;
 
+/**
+ * Base schema for policy transaction response.
+ */
+declare const basePolicyTransactionResponseSchema: z.ZodObject<{
+    locator: z.ZodString;
+    transactionCategory: z.ZodEnum<{
+        issuance: "issuance";
+        change: "change";
+        renewal: "renewal";
+        cancellation: "cancellation";
+        reinstatement: "reinstatement";
+        reversal: "reversal";
+        aggregate: "aggregate";
+    }>;
+    transactionState: z.ZodEnum<{
+        draft: "draft";
+        validated: "validated";
+        earlyUnderwritten: "earlyUnderwritten";
+        priced: "priced";
+        underwritten: "underwritten";
+        accepted: "accepted";
+        issued: "issued";
+        underwrittenBlocked: "underwrittenBlocked";
+        declined: "declined";
+        rejected: "rejected";
+        refused: "refused";
+        discarded: "discarded";
+        initialized: "initialized";
+        invalidated: "invalidated";
+        reversed: "reversed";
+    }>;
+    policyLocator: z.ZodString;
+    baseTransactionLocator: z.ZodOptional<z.ZodString>;
+    aggregateTransactionLocator: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    createdBy: z.ZodUUID;
+    effectiveTime: z.ZodISODateTime;
+    aggregatedTransactions: z.ZodOptional;
+    termLocator: z.ZodString;
+    transactionType: z.ZodString;
+    issuedTime: z.ZodOptional<z.ZodISODateTime>;
+    billingTrigger: z.ZodOptional<z.ZodEnum<{
+        accept: "accept";
+        issue: "issue";
+    }>>;
+    acceptedTime: z.ZodOptional<z.ZodISODateTime>;
+    reapplicationOfLocator: z.ZodOptional<z.ZodString>;
+    maskingLevel: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        level1: "level1";
+        level2: "level2";
+    }>>;
+    anonymizedAt: z.ZodOptional<z.ZodISODateTime>;
+    changeInstructions: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    preferences: z.ZodOptional<z.ZodObject<{
+        billingPreferences: z.ZodOptional<z.ZodObject<{
+            billingPlanName: z.ZodOptional<z.ZodString>;
+            billingLevel: z.ZodOptional<z.ZodEnum<{
+                account: "account";
+                inherit: "inherit";
+                policy: "policy";
+            }>>;
+        }, z.core.$strip>>;
+        installmentPreferences: z.ZodOptional<z.ZodObject<{
+            installmentPlanName: z.ZodOptional<z.ZodString>;
+            anchorMode: z.ZodOptional<z.ZodEnum<{
+                generateDay: "generateDay";
+                termStartDay: "termStartDay";
+                dueDay: "dueDay";
+            }>>;
+            anchorTime: z.ZodOptional<z.ZodString>;
+            anchorType: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                dayOfMonth: "dayOfMonth";
+                anchorTime: "anchorTime";
+                dayOfWeek: "dayOfWeek";
+                weekOfMonth: "weekOfMonth";
+            }>>;
+            cadence: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                fullPay: "fullPay";
+                weekly: "weekly";
+                everyOtherWeek: "everyOtherWeek";
+                monthly: "monthly";
+                quarterly: "quarterly";
+                semiannually: "semiannually";
+                annually: "annually";
+                thirtyDays: "thirtyDays";
+                everyNDays: "everyNDays";
+            }>>;
+            dayOfMonth: z.ZodOptional<z.ZodNumber>;
+            dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                monday: "monday";
+                tuesday: "tuesday";
+                wednesday: "wednesday";
+                thursday: "thursday";
+                friday: "friday";
+                saturday: "saturday";
+                sunday: "sunday";
+            }>>;
+            dueLeadDays: z.ZodOptional<z.ZodNumber>;
+            generateLeadDays: z.ZodOptional<z.ZodNumber>;
+            maxInstallmentsPerTerm: z.ZodOptional<z.ZodNumber>;
+            weekOfMonth: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                first: "first";
+                second: "second";
+                third: "third";
+                fourth: "fourth";
+                fifth: "fifth";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    underwritingStatus: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        declined: "declined";
+        rejected: "rejected";
+        approved: "approved";
+        blocked: "blocked";
+    }>>;
+    validationResult: z.ZodOptional<z.ZodObject<{
+        validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            locator: z.ZodOptional<z.ZodULID>;
+            elementType: z.ZodOptional<z.ZodString>;
+            errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        success: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
 declare const BaseTransactionPriceSchema: z.ZodObject<{
     locator: z.ZodULID;
     policyLocator: z.ZodULID;
@@ -1166,69 +1296,6 @@ declare const BaseTransactionPriceSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
-declare const BaseTransactionUnderwritingResponseSchema: z.ZodObject<{
-    locator: z.ZodULID;
-    policyLocator: z.ZodULID;
-    transactionCategory: z.ZodEnum<{
-        issuance: "issuance";
-        change: "change";
-        renewal: "renewal";
-        cancellation: "cancellation";
-        reinstatement: "reinstatement";
-        reversal: "reversal";
-        aggregate: "aggregate";
-    }>;
-    transactionState: z.ZodEnum<{
-        draft: "draft";
-        validated: "validated";
-        earlyUnderwritten: "earlyUnderwritten";
-        priced: "priced";
-        underwritten: "underwritten";
-        accepted: "accepted";
-        issued: "issued";
-        underwrittenBlocked: "underwrittenBlocked";
-        declined: "declined";
-        rejected: "rejected";
-        refused: "refused";
-        discarded: "discarded";
-        initialized: "initialized";
-        invalidated: "invalidated";
-        reversed: "reversed";
-    }>;
-    effectiveTime: z.ZodISODateTime;
-    underwritingStatus: z.ZodString;
-    underwritingFlags: z.ZodArray<z.ZodObject<{
-        note: z.ZodString;
-        tag: z.ZodString;
-        taskCreationResponse: z.ZodObject<{
-            taskLocator: z.ZodString;
-            status: z.ZodEnum<{
-                succeeded: "succeeded";
-                failed: "failed";
-            }>;
-        }, z.core.$strip>;
-        locator: z.ZodULID;
-        referenceLocator: z.ZodULID;
-        referenceType: z.ZodEnum<{
-            quote: "quote";
-            transaction: "transaction";
-        }>;
-        level: z.ZodEnum<{
-            none: "none";
-            info: "info";
-            block: "block";
-            decline: "decline";
-            reject: "reject";
-            approve: "approve";
-        }>;
-        createdBy: z.ZodGUID;
-        createdTime: z.ZodISODateTime;
-        clearedBy: z.ZodGUID;
-        clearedTime: z.ZodISODateTime;
-        elementLocator: z.ZodOptional<z.ZodULID>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-
 export declare const BasicAndFormerUserBffSchema: z.ZodUnion<readonly [z.ZodObject<{
     locator: z.ZodGUID;
     userName: z.ZodString;
@@ -1547,6 +1614,12 @@ export declare type ClaimId = z.infer<typeof ClaimIdSchema>;
 
 export declare const ClaimIdSchema: z.ZodULID;
 
+export declare const ConditionValueSchema: z.ZodObject<{
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fieldName: z.ZodOptional<z.ZodString>;
+    staticLocator: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
 export declare type ConfigBuilderResult = z.infer<typeof ConfigBuilderResultSchema>;
 
 export declare const ConfigBuilderResultSchema: z.ZodObject<{
@@ -1565,27 +1638,27 @@ export declare type ConsolidatedDocumentRef = z.infer<typeof ConsolidatedDocumen
 export declare type ConsolidatedDocumentRefRecord = z.infer<typeof ConsolidatedDocumentRefRecordSchema>;
 
 export declare const ConsolidatedDocumentRefRecordSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    displayName: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
     consolidatedDocuments: z.ZodArray<z.ZodString>;
-    leadingDocumentTemplate: z.ZodString;
-    pageNumbering: z.ZodObject<{
+    leadingDocumentTemplate: z.ZodOptional<z.ZodString>;
+    pageNumbering: z.ZodOptional<z.ZodObject<{
         enableNumbering: z.ZodBoolean;
         leadingDocumentPages: z.ZodBoolean;
         xPosition: z.ZodInt;
         yPosition: z.ZodInt;
-    }, z.core.$strip>;
+    }, z.core.$strip>>;
 }, z.core.$strip>>;
 
 export declare const ConsolidatedDocumentRefSchema: z.ZodObject<{
-    displayName: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
     consolidatedDocuments: z.ZodArray<z.ZodString>;
-    leadingDocumentTemplate: z.ZodString;
-    pageNumbering: z.ZodObject<{
+    leadingDocumentTemplate: z.ZodOptional<z.ZodString>;
+    pageNumbering: z.ZodOptional<z.ZodObject<{
         enableNumbering: z.ZodBoolean;
         leadingDocumentPages: z.ZodBoolean;
         xPosition: z.ZodInt;
         yPosition: z.ZodInt;
-    }, z.core.$strip>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 
 export declare type ConstraintConfig = z.infer<typeof constraintConfigSchema>;
@@ -1598,6 +1671,18 @@ export declare const constraintConfigSchema: z.ZodOptional<z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>>;
 
+export declare type ConstraintDependency = z.infer<typeof ConstraintDependencySchema>;
+
+export declare const ConstraintDependencySchema: z.ZodObject<{
+    table: z.ZodString;
+    column: z.ZodString;
+    where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fieldName: z.ZodOptional<z.ZodString>;
+        staticLocator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
 export declare type Contact = z.infer<typeof ContactSchema>;
 
 export declare type ContactCreateRequest = z.infer<typeof ContactCreateRequestSchema>;
@@ -3560,15 +3645,15 @@ export declare const dataModelSchema: z.ZodObject<{
         }>>;
     }, z.core.$strip>>>;
     consolidatedDocuments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        displayName: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
         consolidatedDocuments: z.ZodArray<z.ZodString>;
-        leadingDocumentTemplate: z.ZodString;
-        pageNumbering: z.ZodObject<{
+        leadingDocumentTemplate: z.ZodOptional<z.ZodString>;
+        pageNumbering: z.ZodOptional<z.ZodObject<{
             enableNumbering: z.ZodBoolean;
             leadingDocumentPages: z.ZodBoolean;
             xPosition: z.ZodInt;
             yPosition: z.ZodInt;
-        }, z.core.$strip>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     policyLines: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         displayName: z.ZodOptional<z.ZodString>;
@@ -4048,12 +4133,12 @@ export declare const delinquencyStateEnumSchema: z.ZodEnum<{
 export declare type DependencyMapResponse = z.infer<typeof dependencyMapResponseSchema>;
 
 export declare const dependencyMapResponseSchema: z.ZodRecord<z.ZodULID, z.ZodRecord<z.ZodString, z.ZodObject<{
-    column: z.ZodString;
     table: z.ZodString;
+    column: z.ZodString;
     where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        staticLocator: z.ZodOptional<z.ZodString>;
-        fieldName: z.ZodOptional<z.ZodString>;
         values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fieldName: z.ZodOptional<z.ZodString>;
+        staticLocator: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>>>;
 
@@ -6064,6 +6149,7 @@ export declare const InvoiceResponseSchema: z.ZodObject<{
     autopayTime: z.ZodOptional<z.ZodISODateTime>;
     totalAmount: z.ZodOptional<z.ZodNumber>;
     totalRemainingAmount: z.ZodOptional<z.ZodNumber>;
+    settledTime: z.ZodOptional<z.ZodISODateTime>;
 }, z.core.$strip>;
 
 export declare type InvoiceStateEnum = z.infer<typeof InvoiceStateEnumSchema>;
@@ -6108,11 +6194,10 @@ export declare const ledgerAccountReferenceTypeEnumSchema: z.ZodEnum<{
     accountExpenseBalance: "accountExpenseBalance";
 }>;
 
-export declare type LedgerAccountResponse = z.infer<typeof ledgerAccountResponseSchema>;
+export declare type LedgerAccountResponse = z.infer<typeof LedgerAccountResponseSchema>;
 
-export declare const ledgerAccountResponseSchema: z.ZodObject<{
-    referenceLocator: z.ZodString;
-    currency: z.ZodEnum<{
+declare const LedgerAccountResponseSchema: z.ZodObject<{
+    currency: z.ZodOptional<z.ZodEnum<{
         AED: "AED";
         AFN: "AFN";
         ALL: "ALL";
@@ -6292,9 +6377,20 @@ export declare const ledgerAccountResponseSchema: z.ZodObject<{
         ZAR: "ZAR";
         ZMW: "ZMW";
         ZWL: "ZWL";
-    }>;
-    balance: z.ZodNumber;
+    }>>;
+    lineItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        faTransactionLocator: z.ZodString;
+        faTransactionTime: z.ZodISODateTime;
+        faTransactionNote: z.ZodString;
+        accountingType: z.ZodEnum<{
+            credit: "credit";
+            debit: "debit";
+        }>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>>;
+    referenceLocator: z.ZodString;
     referenceType: z.ZodEnum<{
+        account: "account";
         policy: "policy";
         quote: "quote";
         transaction: "transaction";
@@ -6302,39 +6398,240 @@ export declare const ledgerAccountResponseSchema: z.ZodObject<{
         invoiceItem: "invoiceItem";
         cash: "cash";
         accountCreditBalance: "accountCreditBalance";
+        creditCash: "creditCash";
         charge: "charge";
         installmentItem: "installmentItem";
         accountExpenseBalance: "accountExpenseBalance";
     }>;
-    lineItems: z.ZodArray<z.ZodObject<{
-        faTransactionLocator: z.ZodString;
-        accountingType: z.ZodEnum<{
-            credit: "credit";
-            debit: "debit";
-        }>;
-        amount: z.ZodNumber;
-        faTransactionNote: z.ZodString;
-        faTransactionTime: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-
-export declare type ListBasicUserResponse = z.infer<typeof ListBasicUserResponseSchema>;
-
-export declare const ListBasicUserResponseSchema: z.ZodObject<{
-    listCompleted: z.ZodBoolean;
-    items: z.ZodArray<z.ZodObject<{
-        locator: z.ZodGUID;
-        userName: z.ZodString;
-        firstName: z.ZodOptional<z.ZodString>;
-        lastName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    balance: z.ZodNumber;
 }, z.core.$strip>;
 
-export declare type ListPaymentResponse = z.infer<typeof ListPaymentResponseSchema>;
-
-export declare const ListPaymentResponseSchema: z.ZodObject<{
-    listCompleted: z.ZodBoolean;
-    items: z.ZodArray<z.ZodObject<{
+/** @deprecated - use ledgerAccountListResponseSchema instead */
+export declare const ledgerAccountResponseSchema: z.ZodObject<{
+    referenceLocator: z.ZodString;
+    currency: z.ZodOptional<z.ZodEnum<{
+        AED: "AED";
+        AFN: "AFN";
+        ALL: "ALL";
+        AMD: "AMD";
+        ANG: "ANG";
+        AOA: "AOA";
+        ARS: "ARS";
+        AUD: "AUD";
+        AWG: "AWG";
+        AZN: "AZN";
+        BAM: "BAM";
+        BBD: "BBD";
+        BDT: "BDT";
+        BGN: "BGN";
+        BHD: "BHD";
+        BIF: "BIF";
+        BMD: "BMD";
+        BND: "BND";
+        BOB: "BOB";
+        BOV: "BOV";
+        BRL: "BRL";
+        BSD: "BSD";
+        BTN: "BTN";
+        BWP: "BWP";
+        BYN: "BYN";
+        BZD: "BZD";
+        CAD: "CAD";
+        CDF: "CDF";
+        CHE: "CHE";
+        CHF: "CHF";
+        CHW: "CHW";
+        CLF: "CLF";
+        CLP: "CLP";
+        COP: "COP";
+        COU: "COU";
+        CRC: "CRC";
+        CUP: "CUP";
+        CVE: "CVE";
+        CZK: "CZK";
+        DJF: "DJF";
+        DKK: "DKK";
+        DOP: "DOP";
+        DZD: "DZD";
+        EGP: "EGP";
+        ERN: "ERN";
+        ETB: "ETB";
+        EUR: "EUR";
+        FJD: "FJD";
+        FKP: "FKP";
+        GBP: "GBP";
+        GEL: "GEL";
+        GHS: "GHS";
+        GIP: "GIP";
+        GMD: "GMD";
+        GNF: "GNF";
+        GTQ: "GTQ";
+        GYD: "GYD";
+        HKD: "HKD";
+        HNL: "HNL";
+        HTG: "HTG";
+        HUF: "HUF";
+        IDR: "IDR";
+        ILS: "ILS";
+        INR: "INR";
+        IQD: "IQD";
+        IRR: "IRR";
+        ISK: "ISK";
+        JMD: "JMD";
+        JOD: "JOD";
+        JPY: "JPY";
+        KES: "KES";
+        KGS: "KGS";
+        KHR: "KHR";
+        KMF: "KMF";
+        KPW: "KPW";
+        KRW: "KRW";
+        KWD: "KWD";
+        KYD: "KYD";
+        KZT: "KZT";
+        LAK: "LAK";
+        LBP: "LBP";
+        LKR: "LKR";
+        LRD: "LRD";
+        LSL: "LSL";
+        LYD: "LYD";
+        MAD: "MAD";
+        MDL: "MDL";
+        MGA: "MGA";
+        MKD: "MKD";
+        MMK: "MMK";
+        MNT: "MNT";
+        MOP: "MOP";
+        MRU: "MRU";
+        MUR: "MUR";
+        MVR: "MVR";
+        MWK: "MWK";
+        MXN: "MXN";
+        MXV: "MXV";
+        MYR: "MYR";
+        MZN: "MZN";
+        NAD: "NAD";
+        NGN: "NGN";
+        NIO: "NIO";
+        NOK: "NOK";
+        NPR: "NPR";
+        NZD: "NZD";
+        OMR: "OMR";
+        PAB: "PAB";
+        PEN: "PEN";
+        PGK: "PGK";
+        PHP: "PHP";
+        PKR: "PKR";
+        PLN: "PLN";
+        PYG: "PYG";
+        QAR: "QAR";
+        RON: "RON";
+        RSD: "RSD";
+        CNY: "CNY";
+        RUB: "RUB";
+        RWF: "RWF";
+        SAR: "SAR";
+        SBD: "SBD";
+        SCR: "SCR";
+        SDG: "SDG";
+        SEK: "SEK";
+        SGD: "SGD";
+        SHP: "SHP";
+        SLE: "SLE";
+        SLL: "SLL";
+        SOS: "SOS";
+        SRD: "SRD";
+        SSP: "SSP";
+        STN: "STN";
+        SVC: "SVC";
+        SYP: "SYP";
+        SZL: "SZL";
+        THB: "THB";
+        TJS: "TJS";
+        TMT: "TMT";
+        TND: "TND";
+        TOP: "TOP";
+        TRY: "TRY";
+        TTD: "TTD";
+        TWD: "TWD";
+        TZS: "TZS";
+        UAH: "UAH";
+        UGX: "UGX";
+        USD: "USD";
+        USN: "USN";
+        UYI: "UYI";
+        UYU: "UYU";
+        UYW: "UYW";
+        UZS: "UZS";
+        VED: "VED";
+        VES: "VES";
+        VND: "VND";
+        VUV: "VUV";
+        WST: "WST";
+        XAF: "XAF";
+        XAG: "XAG";
+        XAU: "XAU";
+        XBA: "XBA";
+        XBB: "XBB";
+        XBC: "XBC";
+        XBD: "XBD";
+        XCD: "XCD";
+        XDR: "XDR";
+        XOF: "XOF";
+        XPD: "XPD";
+        XPF: "XPF";
+        XPT: "XPT";
+        XSU: "XSU";
+        XTS: "XTS";
+        XUA: "XUA";
+        XXX: "XXX";
+        YER: "YER";
+        ZAR: "ZAR";
+        ZMW: "ZMW";
+        ZWL: "ZWL";
+    }>>;
+    balance: z.ZodNumber;
+    referenceType: z.ZodEnum<{
+        policy: "policy";
+        quote: "quote";
+        transaction: "transaction";
+        credit: "credit";
+        invoiceItem: "invoiceItem";
+        cash: "cash";
+        accountCreditBalance: "accountCreditBalance";
+        charge: "charge";
+        installmentItem: "installmentItem";
+        accountExpenseBalance: "accountExpenseBalance";
+    }>;
+    lineItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        faTransactionLocator: z.ZodString;
+        accountingType: z.ZodEnum<{
+            credit: "credit";
+            debit: "debit";
+        }>;
+        amount: z.ZodNumber;
+        faTransactionNote: z.ZodString;
+        faTransactionTime: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+export declare type ListBasicUserResponse = z.infer<typeof ListBasicUserResponseSchema>;
+
+export declare const ListBasicUserResponseSchema: z.ZodObject<{
+    listCompleted: z.ZodBoolean;
+    items: z.ZodArray<z.ZodObject<{
+        locator: z.ZodGUID;
+        userName: z.ZodString;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+export declare type ListPaymentResponse = z.infer<typeof ListPaymentResponseSchema>;
+
+export declare const ListPaymentResponseSchema: z.ZodObject<{
+    listCompleted: z.ZodBoolean;
+    items: z.ZodArray<z.ZodObject<{
         currency: z.ZodEnum<{
             AED: "AED";
             AFN: "AFN";
@@ -8772,13 +9069,20 @@ export declare const PolicyTransactionListResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
-export declare type PolicyTransactionResponse = z.infer<typeof policyTransactionResponseSchema>;
+export declare type PolicyTransactionResponse = z.infer<typeof basePolicyTransactionResponseSchema> & {
+    aggregatedTransactions?: PolicyTransactionResponse[];
+};
+
+/**
+ * Full schema for policy transaction response with aggregated transactions shaped the same as the base schema.
+ */
+export declare const PolicyTransactionResponseSchema: z.ZodType<PolicyTransactionResponse>;
 
-export declare const PolicyTransactionResponseSchema: z.ZodObject<{
-    locator: z.ZodULID;
-    policyLocator: z.ZodULID;
-    termLocator: z.ZodULID;
-    effectiveTime: z.ZodISODateTime;
+/** @deprecated - use PolicyTransactionResponseSchema instead. */
+export declare const policyTransactionResponseSchema: z.ZodObject<{
+    locator: z.ZodString;
+    policyLocator: z.ZodString;
+    termLocator: z.ZodString;
     transactionState: z.ZodEnum<{
         draft: "draft";
         validated: "validated";
@@ -8796,6 +9100,9 @@ export declare const PolicyTransactionResponseSchema: z.ZodObject<{
         invalidated: "invalidated";
         reversed: "reversed";
     }>;
+    createdAt: z.ZodISODateTime;
+    createdBy: z.ZodGUID;
+    effectiveTime: z.ZodISODateTime;
     transactionCategory: z.ZodEnum<{
         issuance: "issuance";
         change: "change";
@@ -8806,509 +9113,14 @@ export declare const PolicyTransactionResponseSchema: z.ZodObject<{
         aggregate: "aggregate";
     }>;
     transactionType: z.ZodString;
-    createdAt: z.ZodISODateTime;
-    createdBy: z.ZodGUID;
-    aggregateTransactionLocator: z.ZodOptional<z.ZodULID>;
-    baseTransactionLocator: z.ZodOptional<z.ZodULID>;
+    changeInstructions: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    aggregateTransactionLocator: z.ZodOptional<z.ZodString>;
+    baseTransactionLocator: z.ZodOptional<z.ZodString>;
     issuedTime: z.ZodOptional<z.ZodISODateTime>;
-    acceptedTime: z.ZodOptional<z.ZodISODateTime>;
-    preferences: z.ZodOptional<z.ZodObject<{
-        installmentPreferences: z.ZodOptional<z.ZodObject<{
-            generateLeadDays: z.ZodOptional<z.ZodInt>;
-            dueLeadDays: z.ZodOptional<z.ZodInt>;
-            maxInstallmentsPerTerm: z.ZodOptional<z.ZodInt>;
-            installmentPlanName: z.ZodOptional<z.ZodString>;
-            dayOfMonth: z.ZodOptional<z.ZodInt>;
-            anchorTime: z.ZodOptional<z.ZodISODateTime>;
-            autopayLeadDays: z.ZodOptional<z.ZodNumber>;
-            cadence: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                fullPay: "fullPay";
-                weekly: "weekly";
-                everyOtherWeek: "everyOtherWeek";
-                monthly: "monthly";
-                quarterly: "quarterly";
-                semiannually: "semiannually";
-                annually: "annually";
-                thirtyDays: "thirtyDays";
-                everyNDays: "everyNDays";
-            }>>;
-            anchorMode: z.ZodOptional<z.ZodEnum<{
-                generateDay: "generateDay";
-                termStartDay: "termStartDay";
-                dueDay: "dueDay";
-            }>>;
-            anchorType: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                dayOfMonth: "dayOfMonth";
-                anchorTime: "anchorTime";
-                dayOfWeek: "dayOfWeek";
-                weekOfMonth: "weekOfMonth";
-            }>>;
-            dayOfWeek: z.ZodOptional<z.ZodEnum<{
-                monday: "monday";
-                tuesday: "tuesday";
-                wednesday: "wednesday";
-                thursday: "thursday";
-                friday: "friday";
-                saturday: "saturday";
-                sunday: "sunday";
-            }>>;
-            weekOfMonth: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                first: "first";
-                second: "second";
-                third: "third";
-                fourth: "fourth";
-                fifth: "fifth";
-            }>>;
-            installmentWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        }, z.core.$strip>>;
-        billingPreferences: z.ZodOptional<z.ZodObject<{
-            billingPlanName: z.ZodOptional<z.ZodString>;
-            billingLevel: z.ZodEnum<{
-                account: "account";
-                inherit: "inherit";
-                policy: "policy";
-            }>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    underwritingStatus: z.ZodOptional<z.ZodString>;
-    validationResult: z.ZodOptional<z.ZodObject<{
-        validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            locator: z.ZodOptional<z.ZodULID>;
-            elementType: z.ZodOptional<z.ZodString>;
-            errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>;
-        success: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    changeInstructions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        locator: z.ZodULID;
-        action: z.ZodEnum<{
-            delete: "delete";
-            params: "params";
-            modify: "modify";
-            add: "add";
-        }>;
-        elements: z.ZodArray<z.ZodType<{
-            type: string;
-            parentLocator: string;
-            data: Record<string, any>;
-            coverageTerms: Record<string, string>;
-            staticLocator?: string | undefined;
-        } & {
-            elements?: ({
-                type: string;
-                parentLocator: string;
-                data: Record<string, any>;
-                coverageTerms: Record<string, string>;
-                staticLocator?: string | undefined;
-            } & /*elided*/ any)[];
-        }, unknown, z.core.$ZodTypeInternals<{
-            type: string;
-            parentLocator: string;
-            data: Record<string, any>;
-            coverageTerms: Record<string, string>;
-            staticLocator?: string | undefined;
-        } & {
-            elements?: ({
-                type: string;
-                parentLocator: string;
-                data: Record<string, any>;
-                coverageTerms: Record<string, string>;
-                staticLocator?: string | undefined;
-            } & /*elided*/ any)[];
-        }, unknown>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        locator: z.ZodULID;
-        action: z.ZodEnum<{
-            delete: "delete";
-            params: "params";
-            modify: "modify";
-            add: "add";
-        }>;
-        staticLocator: z.ZodULID;
-        setData: z.ZodRecord<z.ZodString, z.ZodAny>;
-        removeData: z.ZodRecord<z.ZodString, z.ZodAny>;
-        setCoverageTerms: z.ZodRecord<z.ZodString, z.ZodString>;
-        removeCoverageTerms: z.ZodRecord<z.ZodString, z.ZodAny>;
-    }, z.core.$strip>, z.ZodObject<{
-        locator: z.ZodULID;
-        action: z.ZodEnum<{
-            delete: "delete";
-            params: "params";
-            modify: "modify";
-            add: "add";
-        }>;
-        effectiveTime: z.ZodISODateTime;
-        newPolicyEndTime: z.ZodOptional<z.ZodISODateTime>;
-        preferences: z.ZodOptional<z.ZodObject<{
-            installmentPreferences: z.ZodOptional<z.ZodObject<{
-                generateLeadDays: z.ZodOptional<z.ZodInt>;
-                dueLeadDays: z.ZodOptional<z.ZodInt>;
-                maxInstallmentsPerTerm: z.ZodOptional<z.ZodInt>;
-                installmentPlanName: z.ZodOptional<z.ZodString>;
-                dayOfMonth: z.ZodOptional<z.ZodInt>;
-                anchorTime: z.ZodOptional<z.ZodISODateTime>;
-                autopayLeadDays: z.ZodOptional<z.ZodNumber>;
-                cadence: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    fullPay: "fullPay";
-                    weekly: "weekly";
-                    everyOtherWeek: "everyOtherWeek";
-                    monthly: "monthly";
-                    quarterly: "quarterly";
-                    semiannually: "semiannually";
-                    annually: "annually";
-                    thirtyDays: "thirtyDays";
-                    everyNDays: "everyNDays";
-                }>>;
-                anchorMode: z.ZodOptional<z.ZodEnum<{
-                    generateDay: "generateDay";
-                    termStartDay: "termStartDay";
-                    dueDay: "dueDay";
-                }>>;
-                anchorType: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    dayOfMonth: "dayOfMonth";
-                    anchorTime: "anchorTime";
-                    dayOfWeek: "dayOfWeek";
-                    weekOfMonth: "weekOfMonth";
-                }>>;
-                dayOfWeek: z.ZodOptional<z.ZodEnum<{
-                    monday: "monday";
-                    tuesday: "tuesday";
-                    wednesday: "wednesday";
-                    thursday: "thursday";
-                    friday: "friday";
-                    saturday: "saturday";
-                    sunday: "sunday";
-                }>>;
-                weekOfMonth: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    first: "first";
-                    second: "second";
-                    third: "third";
-                    fourth: "fourth";
-                    fifth: "fifth";
-                }>>;
-                installmentWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-            }, z.core.$strip>>;
-            billingPreferences: z.ZodOptional<z.ZodObject<{
-                billingPlanName: z.ZodOptional<z.ZodString>;
-                billingLevel: z.ZodEnum<{
-                    account: "account";
-                    inherit: "inherit";
-                    policy: "policy";
-                }>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        triggerBillingChange: z.ZodOptional<z.ZodBoolean>;
-        billingModeChange: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>, z.ZodObject<{
-        locator: z.ZodULID;
-        action: z.ZodEnum<{
-            delete: "delete";
-            params: "params";
-            modify: "modify";
-            add: "add";
-        }>;
-        staticElementLocators: z.ZodArray<z.ZodULID>;
-    }, z.core.$strip>]>>>;
-    billingTrigger: z.ZodEnum<{
-        accept: "accept";
-        issue: "issue";
-    }>;
-    aggregatedTransactions: z.ZodArray<z.ZodObject<{
-        locator: z.ZodULID;
-        policyLocator: z.ZodULID;
-        termLocator: z.ZodULID;
-        effectiveTime: z.ZodISODateTime;
-        transactionState: z.ZodEnum<{
-            draft: "draft";
-            validated: "validated";
-            earlyUnderwritten: "earlyUnderwritten";
-            priced: "priced";
-            underwritten: "underwritten";
-            accepted: "accepted";
-            issued: "issued";
-            underwrittenBlocked: "underwrittenBlocked";
-            declined: "declined";
-            rejected: "rejected";
-            refused: "refused";
-            discarded: "discarded";
-            initialized: "initialized";
-            invalidated: "invalidated";
-            reversed: "reversed";
-        }>;
-        transactionCategory: z.ZodEnum<{
-            issuance: "issuance";
-            change: "change";
-            renewal: "renewal";
-            cancellation: "cancellation";
-            reinstatement: "reinstatement";
-            reversal: "reversal";
-            aggregate: "aggregate";
-        }>;
-        transactionType: z.ZodString;
-        createdAt: z.ZodISODateTime;
-        createdBy: z.ZodGUID;
-        aggregateTransactionLocator: z.ZodOptional<z.ZodULID>;
-        baseTransactionLocator: z.ZodOptional<z.ZodULID>;
-        issuedTime: z.ZodOptional<z.ZodISODateTime>;
-        acceptedTime: z.ZodOptional<z.ZodISODateTime>;
-        preferences: z.ZodOptional<z.ZodObject<{
-            installmentPreferences: z.ZodOptional<z.ZodObject<{
-                generateLeadDays: z.ZodOptional<z.ZodInt>;
-                dueLeadDays: z.ZodOptional<z.ZodInt>;
-                maxInstallmentsPerTerm: z.ZodOptional<z.ZodInt>;
-                installmentPlanName: z.ZodOptional<z.ZodString>;
-                dayOfMonth: z.ZodOptional<z.ZodInt>;
-                anchorTime: z.ZodOptional<z.ZodISODateTime>;
-                autopayLeadDays: z.ZodOptional<z.ZodNumber>;
-                cadence: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    fullPay: "fullPay";
-                    weekly: "weekly";
-                    everyOtherWeek: "everyOtherWeek";
-                    monthly: "monthly";
-                    quarterly: "quarterly";
-                    semiannually: "semiannually";
-                    annually: "annually";
-                    thirtyDays: "thirtyDays";
-                    everyNDays: "everyNDays";
-                }>>;
-                anchorMode: z.ZodOptional<z.ZodEnum<{
-                    generateDay: "generateDay";
-                    termStartDay: "termStartDay";
-                    dueDay: "dueDay";
-                }>>;
-                anchorType: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    dayOfMonth: "dayOfMonth";
-                    anchorTime: "anchorTime";
-                    dayOfWeek: "dayOfWeek";
-                    weekOfMonth: "weekOfMonth";
-                }>>;
-                dayOfWeek: z.ZodOptional<z.ZodEnum<{
-                    monday: "monday";
-                    tuesday: "tuesday";
-                    wednesday: "wednesday";
-                    thursday: "thursday";
-                    friday: "friday";
-                    saturday: "saturday";
-                    sunday: "sunday";
-                }>>;
-                weekOfMonth: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    first: "first";
-                    second: "second";
-                    third: "third";
-                    fourth: "fourth";
-                    fifth: "fifth";
-                }>>;
-                installmentWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-            }, z.core.$strip>>;
-            billingPreferences: z.ZodOptional<z.ZodObject<{
-                billingPlanName: z.ZodOptional<z.ZodString>;
-                billingLevel: z.ZodEnum<{
-                    account: "account";
-                    inherit: "inherit";
-                    policy: "policy";
-                }>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        underwritingStatus: z.ZodOptional<z.ZodString>;
-        validationResult: z.ZodOptional<z.ZodObject<{
-            validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                locator: z.ZodOptional<z.ZodULID>;
-                elementType: z.ZodOptional<z.ZodString>;
-                errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>>;
-            success: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        changeInstructions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            locator: z.ZodULID;
-            action: z.ZodEnum<{
-                delete: "delete";
-                params: "params";
-                modify: "modify";
-                add: "add";
-            }>;
-            elements: z.ZodArray<z.ZodType<{
-                type: string;
-                parentLocator: string;
-                data: Record<string, any>;
-                coverageTerms: Record<string, string>;
-                staticLocator?: string | undefined;
-            } & {
-                elements?: ({
-                    type: string;
-                    parentLocator: string;
-                    data: Record<string, any>;
-                    coverageTerms: Record<string, string>;
-                    staticLocator?: string | undefined;
-                } & /*elided*/ any)[];
-            }, unknown, z.core.$ZodTypeInternals<{
-                type: string;
-                parentLocator: string;
-                data: Record<string, any>;
-                coverageTerms: Record<string, string>;
-                staticLocator?: string | undefined;
-            } & {
-                elements?: ({
-                    type: string;
-                    parentLocator: string;
-                    data: Record<string, any>;
-                    coverageTerms: Record<string, string>;
-                    staticLocator?: string | undefined;
-                } & /*elided*/ any)[];
-            }, unknown>>>;
-        }, z.core.$strip>, z.ZodObject<{
-            locator: z.ZodULID;
-            action: z.ZodEnum<{
-                delete: "delete";
-                params: "params";
-                modify: "modify";
-                add: "add";
-            }>;
-            staticLocator: z.ZodULID;
-            setData: z.ZodRecord<z.ZodString, z.ZodAny>;
-            removeData: z.ZodRecord<z.ZodString, z.ZodAny>;
-            setCoverageTerms: z.ZodRecord<z.ZodString, z.ZodString>;
-            removeCoverageTerms: z.ZodRecord<z.ZodString, z.ZodAny>;
-        }, z.core.$strip>, z.ZodObject<{
-            locator: z.ZodULID;
-            action: z.ZodEnum<{
-                delete: "delete";
-                params: "params";
-                modify: "modify";
-                add: "add";
-            }>;
-            effectiveTime: z.ZodISODateTime;
-            newPolicyEndTime: z.ZodOptional<z.ZodISODateTime>;
-            preferences: z.ZodOptional<z.ZodObject<{
-                installmentPreferences: z.ZodOptional<z.ZodObject<{
-                    generateLeadDays: z.ZodOptional<z.ZodInt>;
-                    dueLeadDays: z.ZodOptional<z.ZodInt>;
-                    maxInstallmentsPerTerm: z.ZodOptional<z.ZodInt>;
-                    installmentPlanName: z.ZodOptional<z.ZodString>;
-                    dayOfMonth: z.ZodOptional<z.ZodInt>;
-                    anchorTime: z.ZodOptional<z.ZodISODateTime>;
-                    autopayLeadDays: z.ZodOptional<z.ZodNumber>;
-                    cadence: z.ZodOptional<z.ZodEnum<{
-                        none: "none";
-                        fullPay: "fullPay";
-                        weekly: "weekly";
-                        everyOtherWeek: "everyOtherWeek";
-                        monthly: "monthly";
-                        quarterly: "quarterly";
-                        semiannually: "semiannually";
-                        annually: "annually";
-                        thirtyDays: "thirtyDays";
-                        everyNDays: "everyNDays";
-                    }>>;
-                    anchorMode: z.ZodOptional<z.ZodEnum<{
-                        generateDay: "generateDay";
-                        termStartDay: "termStartDay";
-                        dueDay: "dueDay";
-                    }>>;
-                    anchorType: z.ZodOptional<z.ZodEnum<{
-                        none: "none";
-                        dayOfMonth: "dayOfMonth";
-                        anchorTime: "anchorTime";
-                        dayOfWeek: "dayOfWeek";
-                        weekOfMonth: "weekOfMonth";
-                    }>>;
-                    dayOfWeek: z.ZodOptional<z.ZodEnum<{
-                        monday: "monday";
-                        tuesday: "tuesday";
-                        wednesday: "wednesday";
-                        thursday: "thursday";
-                        friday: "friday";
-                        saturday: "saturday";
-                        sunday: "sunday";
-                    }>>;
-                    weekOfMonth: z.ZodOptional<z.ZodEnum<{
-                        none: "none";
-                        first: "first";
-                        second: "second";
-                        third: "third";
-                        fourth: "fourth";
-                        fifth: "fifth";
-                    }>>;
-                    installmentWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                }, z.core.$strip>>;
-                billingPreferences: z.ZodOptional<z.ZodObject<{
-                    billingPlanName: z.ZodOptional<z.ZodString>;
-                    billingLevel: z.ZodEnum<{
-                        account: "account";
-                        inherit: "inherit";
-                        policy: "policy";
-                    }>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-            triggerBillingChange: z.ZodOptional<z.ZodBoolean>;
-            billingModeChange: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>, z.ZodObject<{
-            locator: z.ZodULID;
-            action: z.ZodEnum<{
-                delete: "delete";
-                params: "params";
-                modify: "modify";
-                add: "add";
-            }>;
-            staticElementLocators: z.ZodArray<z.ZodULID>;
-        }, z.core.$strip>]>>>;
-        billingTrigger: z.ZodEnum<{
-            accept: "accept";
-            issue: "issue";
-        }>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-
-export declare const policyTransactionResponseSchema: z.ZodObject<{
-    locator: z.ZodString;
-    policyLocator: z.ZodString;
-    termLocator: z.ZodString;
-    transactionState: z.ZodEnum<{
-        draft: "draft";
-        validated: "validated";
-        earlyUnderwritten: "earlyUnderwritten";
-        priced: "priced";
-        underwritten: "underwritten";
-        accepted: "accepted";
-        issued: "issued";
-        underwrittenBlocked: "underwrittenBlocked";
-        declined: "declined";
-        rejected: "rejected";
-        refused: "refused";
-        discarded: "discarded";
-        initialized: "initialized";
-        invalidated: "invalidated";
-        reversed: "reversed";
-    }>;
-    createdAt: z.ZodISODateTime;
-    createdBy: z.ZodGUID;
-    effectiveTime: z.ZodISODateTime;
-    transactionCategory: z.ZodEnum<{
-        issuance: "issuance";
-        change: "change";
-        renewal: "renewal";
-        cancellation: "cancellation";
-        reinstatement: "reinstatement";
-        reversal: "reversal";
-        aggregate: "aggregate";
-    }>;
-    transactionType: z.ZodString;
-    changeInstructions: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-    aggregateTransactionLocator: z.ZodOptional<z.ZodString>;
-    baseTransactionLocator: z.ZodOptional<z.ZodString>;
-    issuedTime: z.ZodOptional<z.ZodISODateTime>;
-    billingTrigger: z.ZodOptional<z.ZodEnum<{
-        accept: "accept";
-        issue: "issue";
-    }>>;
+    billingTrigger: z.ZodOptional<z.ZodEnum<{
+        accept: "accept";
+        issue: "issue";
+    }>>;
     preferences: z.ZodOptional<z.ZodObject<{
         billingPreferences: z.ZodOptional<z.ZodObject<{
             billingPlanName: z.ZodOptional<z.ZodString>;
@@ -11238,7 +11050,7 @@ export declare const quoteStateSchema: z.ZodUnion<readonly [z.ZodEnum<{
     discarded: "discarded";
 }>, z.ZodString]>;
 
-export declare type QuoteUnderwritingFlagsResponse = z.infer<typeof quoteUnderwritingFlagsResponse>;
+export declare type QuoteUnderwritingFlagsResponse = z.infer<typeof QuoteUnderwritingFlagsResponseSchema>;
 
 export declare const quoteUnderwritingFlagsResponse: z.ZodObject<{
     quoteLocator: z.ZodString;
@@ -11286,22 +11098,8 @@ export declare const quoteUnderwritingFlagsResponse: z.ZodObject<{
 
 export declare const QuoteUnderwritingFlagsResponseSchema: z.ZodObject<{
     quoteLocator: z.ZodULID;
-    flags: z.ZodArray<z.ZodObject<{
-        note: z.ZodString;
-        tag: z.ZodString;
-        taskCreationResponse: z.ZodObject<{
-            taskLocator: z.ZodString;
-            status: z.ZodEnum<{
-                succeeded: "succeeded";
-                failed: "failed";
-            }>;
-        }, z.core.$strip>;
+    flags: z.ZodOptional<z.ZodArray<z.ZodObject<{
         locator: z.ZodULID;
-        referenceLocator: z.ZodULID;
-        referenceType: z.ZodEnum<{
-            quote: "quote";
-            transaction: "transaction";
-        }>;
         level: z.ZodEnum<{
             none: "none";
             info: "info";
@@ -11310,28 +11108,28 @@ export declare const QuoteUnderwritingFlagsResponseSchema: z.ZodObject<{
             reject: "reject";
             approve: "approve";
         }>;
-        createdBy: z.ZodGUID;
-        createdTime: z.ZodISODateTime;
-        clearedBy: z.ZodGUID;
-        clearedTime: z.ZodISODateTime;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
+        }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
+        note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
         elementLocator: z.ZodOptional<z.ZodULID>;
-    }, z.core.$strip>>;
-    clearedFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        note: z.ZodString;
-        tag: z.ZodString;
-        taskCreationResponse: z.ZodObject<{
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
             taskLocator: z.ZodString;
             status: z.ZodEnum<{
                 succeeded: "succeeded";
                 failed: "failed";
             }>;
-        }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    clearedFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
         locator: z.ZodULID;
-        referenceLocator: z.ZodULID;
-        referenceType: z.ZodEnum<{
-            quote: "quote";
-            transaction: "transaction";
-        }>;
         level: z.ZodEnum<{
             none: "none";
             info: "info";
@@ -11340,21 +11138,35 @@ export declare const QuoteUnderwritingFlagsResponseSchema: z.ZodObject<{
             reject: "reject";
             approve: "approve";
         }>;
-        createdBy: z.ZodGUID;
-        createdTime: z.ZodISODateTime;
-        clearedBy: z.ZodGUID;
-        clearedTime: z.ZodISODateTime;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
+        }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
+        note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
         elementLocator: z.ZodOptional<z.ZodULID>;
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
+            taskLocator: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 
 export declare type QuoteUnderwritingResponse = z.infer<typeof QuoteUnderwritingResponseSchema>;
 
 export declare const QuoteUnderwritingResponseSchema: z.ZodObject<{
-    tenantLocator: z.ZodUUID;
-    accountLocator: z.ZodULID;
-    quoteLocator: z.ZodULID;
-    quoteState: z.ZodEnum<{
+    tenantLocator: z.ZodOptional<z.ZodOptional<z.ZodUUID>>;
+    quoteLocator: z.ZodOptional<z.ZodULID>;
+    accountLocator: z.ZodOptional<z.ZodOptional<z.ZodULID>>;
+    quoteState: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
         draft: "draft";
         validated: "validated";
         earlyUnderwritten: "earlyUnderwritten";
@@ -11367,11 +11179,11 @@ export declare const QuoteUnderwritingResponseSchema: z.ZodObject<{
         rejected: "rejected";
         refused: "refused";
         discarded: "discarded";
-    }>;
-    startTime: z.ZodISODateTime;
-    endTime: z.ZodISODateTime;
-    expirationTime: z.ZodISODateTime;
-    durationBasis: z.ZodEnum<{
+    }>>>;
+    startTime: z.ZodOptional<z.ZodOptional<z.ZodISODateTime>>;
+    endTime: z.ZodOptional<z.ZodOptional<z.ZodISODateTime>>;
+    expirationTime: z.ZodOptional<z.ZodOptional<z.ZodISODateTime>>;
+    durationBasis: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
         none: "none";
         years: "years";
         months: "months";
@@ -11379,23 +11191,9 @@ export declare const QuoteUnderwritingResponseSchema: z.ZodObject<{
         weeks: "weeks";
         days: "days";
         hours: "hours";
-    }>;
-    underwritingFlags: z.ZodArray<z.ZodObject<{
-        note: z.ZodString;
-        tag: z.ZodString;
-        taskCreationResponse: z.ZodObject<{
-            taskLocator: z.ZodString;
-            status: z.ZodEnum<{
-                succeeded: "succeeded";
-                failed: "failed";
-            }>;
-        }, z.core.$strip>;
+    }>>>;
+    underwritingFlags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
         locator: z.ZodULID;
-        referenceLocator: z.ZodULID;
-        referenceType: z.ZodEnum<{
-            quote: "quote";
-            transaction: "transaction";
-        }>;
         level: z.ZodEnum<{
             none: "none";
             info: "info";
@@ -11404,23 +11202,37 @@ export declare const QuoteUnderwritingResponseSchema: z.ZodObject<{
             reject: "reject";
             approve: "approve";
         }>;
-        createdBy: z.ZodGUID;
-        createdTime: z.ZodISODateTime;
-        clearedBy: z.ZodGUID;
-        clearedTime: z.ZodISODateTime;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
+        }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
+        note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
         elementLocator: z.ZodOptional<z.ZodULID>;
-    }, z.core.$strip>>;
-    validationResult: z.ZodOptional<z.ZodObject<{
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
+            taskLocator: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>>;
+    validationResult: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
             locator: z.ZodOptional<z.ZodULID>;
             elementType: z.ZodOptional<z.ZodString>;
             errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>>;
         success: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    productName: z.ZodString;
-    duration: z.ZodNumber;
-    underwritingStatus: z.ZodString;
+    }, z.core.$strip>>>;
+    productName: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    underwritingStatus: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
 export declare type QuoteUpdateRequest = z.infer<typeof QuoteUpdateRequestSchema>;
@@ -12667,7 +12479,7 @@ export declare const TemplateSnippetConfigSchema: z.ZodObject<{
         policyStartTime: "policyStartTime";
         currentTime: "currentTime";
     }>;
-    displayName: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
 export declare type TenantBaseConfig = z.infer<typeof tenantBaseConfigSchema>;
@@ -13449,6 +13261,7 @@ export declare const timezoneEnumSchema: z.ZodEnum<{
 
 export declare type TimezoneType = z.infer<typeof timezoneEnumSchema>;
 
+/** @deprecated - use TransactionCategoryEnum */
 export declare type TransactionCategory = z.infer<typeof transactionCategoryEnumSchema>;
 
 export declare type TransactionCategoryEnum = z.infer<typeof TransactionCategoryEnumSchema>;
@@ -13463,6 +13276,7 @@ export declare const TransactionCategoryEnumSchema: z.ZodEnum<{
     aggregate: "aggregate";
 }>;
 
+/** @deprecated - use TransactionCategoryEnumSchema*/
 export declare const transactionCategoryEnumSchema: z.ZodEnum<{
     issuance: "issuance";
     change: "change";
@@ -13886,6 +13700,7 @@ export declare const transactionSnapshotResponseSchema: z.ZodObject<{
     transactionType: z.ZodString;
 }, z.core.$strip>;
 
+/** @deprecated - use TransactionStateEnum */
 export declare type TransactionState = z.infer<typeof transactionStateEnumSchema>;
 
 export declare type TransactionStateEnum = z.infer<typeof TransactionStateEnumSchema>;
@@ -13908,6 +13723,7 @@ export declare const TransactionStateEnumSchema: z.ZodEnum<{
     reversed: "reversed";
 }>;
 
+/** @deprecated - use TransactionStateEnumSchema */
 export declare const transactionStateEnumSchema: z.ZodEnum<{
     draft: "draft";
     validated: "validated";
@@ -13968,41 +13784,142 @@ export declare const transactionTypesRecordsSchema: z.ZodRecord<z.ZodString, z.Z
     costBearing: z.ZodBoolean;
 }, z.core.$strip>>;
 
-export declare type TransactionUnderwritingFlagsResponse = z.infer<typeof transactionUnderwritingFlagsResponse>;
+export declare type TransactionUnderwritingFlagsResponse = z.infer<typeof TransactionUnderwritingFlagsResponseSchema>;
 
+/** @deprecated - use TransactionUnderwritingFlagsResponseSchema  */
 export declare const transactionUnderwritingFlagsResponse: z.ZodObject<{
     transactionLocator: z.ZodString;
     clearedFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        locator: z.ZodString;
-        elementLocator: z.ZodOptional<z.ZodString>;
-        clearedBy: z.ZodOptional<z.ZodGUID>;
-        clearedTime: z.ZodOptional<z.ZodString>;
-        createdBy: z.ZodOptional<z.ZodGUID>;
-        createdTime: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodEnum<{
+        locator: z.ZodULID;
+        level: z.ZodEnum<{
+            none: "none";
+            info: "info";
+            block: "block";
+            decline: "decline";
+            reject: "reject";
+            approve: "approve";
+        }>;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
+        }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
+        note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        elementLocator: z.ZodOptional<z.ZodULID>;
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
+            taskLocator: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    flags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        locator: z.ZodULID;
+        level: z.ZodEnum<{
+            none: "none";
+            info: "info";
+            block: "block";
+            decline: "decline";
+            reject: "reject";
+            approve: "approve";
+        }>;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
+        }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
+        note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        elementLocator: z.ZodOptional<z.ZodULID>;
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
+            taskLocator: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    validationResult: z.ZodOptional<z.ZodObject<{
+        validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            locator: z.ZodOptional<z.ZodULID>;
+            elementType: z.ZodOptional<z.ZodString>;
+            errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        success: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+export declare const TransactionUnderwritingFlagsResponseSchema: z.ZodObject<{
+    transactionLocator: z.ZodString;
+    clearedFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        locator: z.ZodULID;
+        level: z.ZodEnum<{
+            none: "none";
             info: "info";
             block: "block";
             decline: "decline";
             reject: "reject";
             approve: "approve";
+        }>;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
         }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
         note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        elementLocator: z.ZodOptional<z.ZodULID>;
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
+            taskLocator: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     flags: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        locator: z.ZodString;
-        elementLocator: z.ZodOptional<z.ZodString>;
-        clearedBy: z.ZodOptional<z.ZodGUID>;
-        clearedTime: z.ZodOptional<z.ZodString>;
-        createdBy: z.ZodOptional<z.ZodGUID>;
-        createdTime: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodEnum<{
+        locator: z.ZodULID;
+        level: z.ZodEnum<{
+            none: "none";
             info: "info";
             block: "block";
             decline: "decline";
             reject: "reject";
             approve: "approve";
+        }>;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
         }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
         note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        elementLocator: z.ZodOptional<z.ZodULID>;
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
+            taskLocator: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     validationResult: z.ZodOptional<z.ZodObject<{
         validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -14014,24 +13931,40 @@ export declare const transactionUnderwritingFlagsResponse: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
-export declare const TransactionUnderwritingFlagsResponseSchema: z.ZodObject<{
-    transactionLocator: z.ZodULID;
-    clearedFlags: z.ZodArray<z.ZodObject<{
-        note: z.ZodString;
-        tag: z.ZodString;
-        taskCreationResponse: z.ZodObject<{
-            taskLocator: z.ZodString;
-            status: z.ZodEnum<{
-                succeeded: "succeeded";
-                failed: "failed";
-            }>;
-        }, z.core.$strip>;
-        locator: z.ZodULID;
-        referenceLocator: z.ZodULID;
-        referenceType: z.ZodEnum<{
-            quote: "quote";
-            transaction: "transaction";
-        }>;
+export declare type TransactionUnderwritingResponse = z.infer<typeof TransactionUnderwritingResponseSchema>;
+
+export declare const TransactionUnderwritingResponseSchema: z.ZodObject<{
+    locator: z.ZodString;
+    policyLocator: z.ZodString;
+    transactionCategory: z.ZodEnum<{
+        issuance: "issuance";
+        change: "change";
+        renewal: "renewal";
+        cancellation: "cancellation";
+        reinstatement: "reinstatement";
+        reversal: "reversal";
+        aggregate: "aggregate";
+    }>;
+    transactionState: z.ZodEnum<{
+        draft: "draft";
+        validated: "validated";
+        earlyUnderwritten: "earlyUnderwritten";
+        priced: "priced";
+        underwritten: "underwritten";
+        accepted: "accepted";
+        issued: "issued";
+        underwrittenBlocked: "underwrittenBlocked";
+        declined: "declined";
+        rejected: "rejected";
+        refused: "refused";
+        discarded: "discarded";
+        initialized: "initialized";
+        invalidated: "invalidated";
+        reversed: "reversed";
+    }>;
+    effectiveTime: z.ZodISODateTime;
+    underwritingFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        locator: z.ZodString;
         level: z.ZodEnum<{
             none: "none";
             info: "info";
@@ -14040,15 +13973,18 @@ export declare const TransactionUnderwritingFlagsResponseSchema: z.ZodObject<{
             reject: "reject";
             approve: "approve";
         }>;
-        createdBy: z.ZodGUID;
-        createdTime: z.ZodISODateTime;
-        clearedBy: z.ZodGUID;
-        clearedTime: z.ZodISODateTime;
-        elementLocator: z.ZodOptional<z.ZodULID>;
-    }, z.core.$strip>>;
-    flags: z.ZodArray<z.ZodObject<{
+        referenceType: z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
+        }>;
+        referenceLocator: z.ZodString;
         note: z.ZodString;
         tag: z.ZodString;
+        elementLocator: z.ZodOptional<z.ZodString>;
+        createdBy: z.ZodUUID;
+        createdTime: z.ZodISODateTime;
+        clearedBy: z.ZodUUID;
+        clearedTime: z.ZodISODateTime;
         taskCreationResponse: z.ZodObject<{
             taskLocator: z.ZodString;
             status: z.ZodEnum<{
@@ -14056,36 +13992,86 @@ export declare const TransactionUnderwritingFlagsResponseSchema: z.ZodObject<{
                 failed: "failed";
             }>;
         }, z.core.$strip>;
-        locator: z.ZodULID;
-        referenceLocator: z.ZodULID;
-        referenceType: z.ZodEnum<{
-            quote: "quote";
-            transaction: "transaction";
+    }, z.core.$strip>>>;
+    underwritingStatus: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        declined: "declined";
+        rejected: "rejected";
+        approved: "approved";
+        blocked: "blocked";
+    }>>;
+    aggregatedTransactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        locator: z.ZodString;
+        policyLocator: z.ZodString;
+        transactionCategory: z.ZodEnum<{
+            issuance: "issuance";
+            change: "change";
+            renewal: "renewal";
+            cancellation: "cancellation";
+            reinstatement: "reinstatement";
+            reversal: "reversal";
+            aggregate: "aggregate";
         }>;
-        level: z.ZodEnum<{
-            none: "none";
-            info: "info";
-            block: "block";
-            decline: "decline";
-            reject: "reject";
-            approve: "approve";
+        transactionState: z.ZodEnum<{
+            draft: "draft";
+            validated: "validated";
+            earlyUnderwritten: "earlyUnderwritten";
+            priced: "priced";
+            underwritten: "underwritten";
+            accepted: "accepted";
+            issued: "issued";
+            underwrittenBlocked: "underwrittenBlocked";
+            declined: "declined";
+            rejected: "rejected";
+            refused: "refused";
+            discarded: "discarded";
+            initialized: "initialized";
+            invalidated: "invalidated";
+            reversed: "reversed";
         }>;
-        createdBy: z.ZodGUID;
-        createdTime: z.ZodISODateTime;
-        clearedBy: z.ZodGUID;
-        clearedTime: z.ZodISODateTime;
-        elementLocator: z.ZodOptional<z.ZodULID>;
+        effectiveTime: z.ZodISODateTime;
+        underwritingFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            locator: z.ZodString;
+            level: z.ZodEnum<{
+                none: "none";
+                info: "info";
+                block: "block";
+                decline: "decline";
+                reject: "reject";
+                approve: "approve";
+            }>;
+            referenceType: z.ZodEnum<{
+                quote: "quote";
+                transaction: "transaction";
+            }>;
+            referenceLocator: z.ZodString;
+            note: z.ZodString;
+            tag: z.ZodString;
+            elementLocator: z.ZodOptional<z.ZodString>;
+            createdBy: z.ZodUUID;
+            createdTime: z.ZodISODateTime;
+            clearedBy: z.ZodUUID;
+            clearedTime: z.ZodISODateTime;
+            taskCreationResponse: z.ZodObject<{
+                taskLocator: z.ZodString;
+                status: z.ZodEnum<{
+                    succeeded: "succeeded";
+                    failed: "failed";
+                }>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    validationResult: z.ZodOptional<z.ZodObject<{
+        validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            locator: z.ZodOptional<z.ZodULID>;
+            elementType: z.ZodOptional<z.ZodString>;
+            errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        success: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
-export declare type TransactionUnderwritingResponse = z.infer<typeof transactionUnderwritingResponseSchema>;
-
-declare type TransactionUnderwritingResponse_2 = z.infer<typeof BaseTransactionUnderwritingResponseSchema> & {
-    aggregatedTransactions?: TransactionUnderwritingResponse_2[];
-};
-
-export declare const TransactionUnderwritingResponseSchema: z.ZodType<TransactionUnderwritingResponse_2>;
-
+/** @deprecated - use TransactionUnderwritingResponseSchema */
 export declare const transactionUnderwritingResponseSchema: z.ZodObject<{
     locator: z.ZodString;
     policyLocator: z.ZodString;
@@ -14116,22 +14102,42 @@ export declare const transactionUnderwritingResponseSchema: z.ZodObject<{
         reversal: "reversal";
         aggregate: "aggregate";
     }>;
-    underwritingStatus: z.ZodOptional<z.ZodString>;
+    underwritingStatus: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        declined: "declined";
+        rejected: "rejected";
+        approved: "approved";
+        blocked: "blocked";
+    }>>;
     underwritingFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        locator: z.ZodString;
-        elementLocator: z.ZodOptional<z.ZodString>;
-        clearedBy: z.ZodOptional<z.ZodGUID>;
-        clearedTime: z.ZodOptional<z.ZodString>;
-        createdBy: z.ZodOptional<z.ZodGUID>;
-        createdTime: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodEnum<{
+        locator: z.ZodULID;
+        level: z.ZodEnum<{
+            none: "none";
             info: "info";
             block: "block";
             decline: "decline";
             reject: "reject";
             approve: "approve";
+        }>;
+        referenceType: z.ZodOptional<z.ZodEnum<{
+            quote: "quote";
+            transaction: "transaction";
         }>>;
+        referenceLocator: z.ZodOptional<z.ZodULID>;
         note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        elementLocator: z.ZodOptional<z.ZodULID>;
+        createdBy: z.ZodOptional<z.ZodUUID>;
+        createdTime: z.ZodOptional<z.ZodISODateTime>;
+        clearedBy: z.ZodOptional<z.ZodUUID>;
+        clearedTime: z.ZodOptional<z.ZodISODateTime>;
+        taskCreationResponse: z.ZodOptional<z.ZodObject<{
+            taskLocator: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     validationResult: z.ZodOptional<z.ZodObject<{
         validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -14171,22 +14177,42 @@ export declare const transactionUnderwritingResponseSchema: z.ZodObject<{
             reversal: "reversal";
             aggregate: "aggregate";
         }>;
-        underwritingStatus: z.ZodOptional<z.ZodString>;
+        underwritingStatus: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            declined: "declined";
+            rejected: "rejected";
+            approved: "approved";
+            blocked: "blocked";
+        }>>;
         underwritingFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            locator: z.ZodString;
-            elementLocator: z.ZodOptional<z.ZodString>;
-            clearedBy: z.ZodOptional<z.ZodGUID>;
-            clearedTime: z.ZodOptional<z.ZodString>;
-            createdBy: z.ZodOptional<z.ZodGUID>;
-            createdTime: z.ZodOptional<z.ZodString>;
-            level: z.ZodOptional<z.ZodEnum<{
+            locator: z.ZodULID;
+            level: z.ZodEnum<{
+                none: "none";
                 info: "info";
                 block: "block";
                 decline: "decline";
                 reject: "reject";
                 approve: "approve";
+            }>;
+            referenceType: z.ZodOptional<z.ZodEnum<{
+                quote: "quote";
+                transaction: "transaction";
             }>>;
+            referenceLocator: z.ZodOptional<z.ZodULID>;
             note: z.ZodOptional<z.ZodString>;
+            tag: z.ZodOptional<z.ZodString>;
+            elementLocator: z.ZodOptional<z.ZodULID>;
+            createdBy: z.ZodOptional<z.ZodUUID>;
+            createdTime: z.ZodOptional<z.ZodISODateTime>;
+            clearedBy: z.ZodOptional<z.ZodUUID>;
+            clearedTime: z.ZodOptional<z.ZodISODateTime>;
+            taskCreationResponse: z.ZodOptional<z.ZodObject<{
+                taskLocator: z.ZodString;
+                status: z.ZodEnum<{
+                    succeeded: "succeeded";
+                    failed: "failed";
+                }>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         validationResult: z.ZodOptional<z.ZodObject<{
             validationItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -14201,12 +14227,10 @@ export declare const transactionUnderwritingResponseSchema: z.ZodObject<{
 
 export declare const ULIDZ: z.ZodULID;
 
-export declare type UnderwritingFlagCreateRequest = z.infer<typeof underwritingFlagCreateRequestSchema>;
+export declare type UnderwritingFlagCreateRequest = z.infer<typeof UnderwritingFlagCreateRequestSchema>;
 
 export declare const UnderwritingFlagCreateRequestSchema: z.ZodObject<{
-    note: z.ZodString;
-    tag: z.ZodString;
-    elementLocator: z.ZodULID;
+    elementLocator: z.ZodOptional<z.ZodULID>;
     level: z.ZodEnum<{
         none: "none";
         info: "info";
@@ -14215,8 +14239,10 @@ export declare const UnderwritingFlagCreateRequestSchema: z.ZodObject<{
         reject: "reject";
         approve: "approve";
     }>;
+    note: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
     taskCreation: z.ZodOptional<z.ZodObject<{
-        deadlineTime: z.ZodISODateTime;
+        type: z.ZodString;
         references: z.ZodArray<z.ZodObject<{
             referenceType: z.ZodEnum<{
                 account: "account";
@@ -14230,13 +14256,14 @@ export declare const UnderwritingFlagCreateRequestSchema: z.ZodObject<{
             }>;
             referenceLocator: z.ZodString;
         }, z.core.$strip>>;
-        assignedTo: z.ZodOptional<z.ZodGUID>;
-        type: z.ZodString;
         underwritingFlagLocators: z.ZodArray<z.ZodString>;
+        deadlineTime: z.ZodOptional<z.ZodISODateTime>;
+        assignedTo: z.ZodOptional<z.ZodUUID>;
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
+/** @deprecated - use UnderwritingFlagCreateRequestSchema */
 export declare const underwritingFlagCreateRequestSchema: z.ZodObject<{
     elementLocator: z.ZodString;
     level: z.ZodEnum<{
@@ -14249,8 +14276,10 @@ export declare const underwritingFlagCreateRequestSchema: z.ZodObject<{
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
+/** @deprecated - use UnderwritingFlagsLevelEnum */
 export declare type UnderwritingFlagEnum = z.infer<typeof underwritingFlagEnumSchema>;
 
+/** @deprecated - use UnderwritingFlagsLevelEnumSchema */
 export declare const underwritingFlagEnumSchema: z.ZodEnum<{
     info: "info";
     block: "block";
@@ -14259,24 +14288,10 @@ export declare const underwritingFlagEnumSchema: z.ZodEnum<{
     approve: "approve";
 }>;
 
-export declare type UnderwritingFlagResponse = z.infer<typeof underwritingFlagResponseSchema>;
+export declare type UnderwritingFlagResponse = z.infer<typeof UnderwritingFlagResponseSchema>;
 
 export declare const UnderwritingFlagResponseSchema: z.ZodObject<{
-    note: z.ZodString;
-    tag: z.ZodString;
-    taskCreationResponse: z.ZodObject<{
-        taskLocator: z.ZodString;
-        status: z.ZodEnum<{
-            succeeded: "succeeded";
-            failed: "failed";
-        }>;
-    }, z.core.$strip>;
     locator: z.ZodULID;
-    referenceLocator: z.ZodULID;
-    referenceType: z.ZodEnum<{
-        quote: "quote";
-        transaction: "transaction";
-    }>;
     level: z.ZodEnum<{
         none: "none";
         info: "info";
@@ -14285,13 +14300,28 @@ export declare const UnderwritingFlagResponseSchema: z.ZodObject<{
         reject: "reject";
         approve: "approve";
     }>;
-    createdBy: z.ZodGUID;
-    createdTime: z.ZodISODateTime;
-    clearedBy: z.ZodGUID;
-    clearedTime: z.ZodISODateTime;
+    referenceType: z.ZodOptional<z.ZodEnum<{
+        quote: "quote";
+        transaction: "transaction";
+    }>>;
+    referenceLocator: z.ZodOptional<z.ZodULID>;
+    note: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
     elementLocator: z.ZodOptional<z.ZodULID>;
+    createdBy: z.ZodOptional<z.ZodUUID>;
+    createdTime: z.ZodOptional<z.ZodISODateTime>;
+    clearedBy: z.ZodOptional<z.ZodUUID>;
+    clearedTime: z.ZodOptional<z.ZodISODateTime>;
+    taskCreationResponse: z.ZodOptional<z.ZodObject<{
+        taskLocator: z.ZodString;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 
+/** @deprecated - use UnderwritingFlagResponseSchema */
 export declare const underwritingFlagResponseSchema: z.ZodObject<{
     locator: z.ZodString;
     elementLocator: z.ZodOptional<z.ZodString>;
@@ -14327,13 +14357,11 @@ export declare const UnderwritingFlagsReferenceTypeEnumSchema: z.ZodEnum<{
     transaction: "transaction";
 }>;
 
-export declare type UnderwritingFlagsUpdateRequest = z.infer<typeof underwritingFlagsUpdateRequestSchema>;
+export declare type UnderwritingFlagsUpdateRequest = z.infer<typeof UnderwritingFlagsUpdateRequestSchema>;
 
 export declare const UnderwritingFlagsUpdateRequestSchema: z.ZodObject<{
-    addFlags: z.ZodArray<z.ZodObject<{
-        note: z.ZodString;
-        tag: z.ZodString;
-        elementLocator: z.ZodULID;
+    addFlags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        elementLocator: z.ZodOptional<z.ZodULID>;
         level: z.ZodEnum<{
             none: "none";
             info: "info";
@@ -14342,8 +14370,10 @@ export declare const UnderwritingFlagsUpdateRequestSchema: z.ZodObject<{
             reject: "reject";
             approve: "approve";
         }>;
+        note: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
         taskCreation: z.ZodOptional<z.ZodObject<{
-            deadlineTime: z.ZodISODateTime;
+            type: z.ZodString;
             references: z.ZodArray<z.ZodObject<{
                 referenceType: z.ZodEnum<{
                     account: "account";
@@ -14357,15 +14387,16 @@ export declare const UnderwritingFlagsUpdateRequestSchema: z.ZodObject<{
                 }>;
                 referenceLocator: z.ZodString;
             }, z.core.$strip>>;
-            assignedTo: z.ZodOptional<z.ZodGUID>;
-            type: z.ZodString;
             underwritingFlagLocators: z.ZodArray<z.ZodString>;
+            deadlineTime: z.ZodOptional<z.ZodISODateTime>;
+            assignedTo: z.ZodOptional<z.ZodUUID>;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    clearFlags: z.ZodArray<z.ZodULID>;
+    }, z.core.$strip>>>;
+    clearFlags: z.ZodOptional<z.ZodArray<z.ZodULID>>;
 }, z.core.$strip>;
 
+/** @deprecated - use UnderwritingFlagsUpdateRequestSchema */
 export declare const underwritingFlagsUpdateRequestSchema: z.ZodObject<{
     addFlags: z.ZodArray<z.ZodObject<{
         elementLocator: z.ZodString;