@propxchain/core-client 0.2.1-canary.9 → 0.3.0-canary.23

package/src/canisters/document_verification/document_verification.did

@@ -3,15 +3,137 @@ type VerificationMethod =
    commercial_api: text;
    dvla_api;
    manual_solicitor;
+   oscar_ai: OscarVerificationDetails;
    passport_dcs;
    system_hash_only;
  };
+type TransactionVerificationSummary = 
+ record {
+   allDocumentsVerified: bool;
+   allLRDocumentsCurrent: bool;
+   daysUntilSearchExpiry: opt int;
+   expiredDocuments: nat;
+   hasOfficialSearch: bool;
+   lrDocuments: vec LRDocumentSummary;
+   missingDocuments: vec text;
+   officialSearchExpiry: opt int;
+   officialSearchValid: bool;
+   readyForCompletion: bool;
+   readyForExchange: bool;
+   readyForSubmission: bool;
+   titleNumber: text;
+   totalDocuments: nat;
+   transactionId: text;
+   unverifiedDocuments: nat;
+   verifiedDocuments: nat;
+ };
 type Time = int;
+type Result_4 = 
+ variant {
+   err: text;
+   ok: TransactionVerificationSummary;
+ };
+type Result_3 = 
+ variant {
+   err: text;
+   ok: nat;
+ };
+type Result_2 = 
+ variant {
+   err: text;
+   ok: OfficialCopyVerification;
+ };
+type Result_1 = 
+ variant {
+   err: text;
+   ok: OSCertificateVerification;
+ };
 type Result = 
  variant {
    err: text;
    ok: DocumentVerification;
  };
+type PriorityStatus = 
+ variant {
+   Active;
+   Expired;
+   ExpiringImminently;
+   Unknown;
+ };
+type OscarVerificationInput = 
+ record {
+   confidence: nat;
+   documentType: text;
+   extractedData: text;
+   issues: vec OscarIssue;
+   mismatches: vec DataMismatch;
+   requiresSolicitorReview: bool;
+ };
+type OscarVerificationDetails = 
+ record {
+   analysisTimestamp: Time;
+   confidence: nat;
+   documentType: text;
+   extractedData: text;
+   issues: vec OscarIssue;
+   mismatches: vec DataMismatch;
+   requiresSolicitorReview: bool;
+ };
+type OscarIssue = 
+ record {
+   code: text;
+   field: opt text;
+   message: text;
+   severity: variant {
+               error;
+               info;
+               warning;
+             };
+ };
+type OfficialCopyVerification = 
+ record {
+   copyType: LRDocumentType;
+   documentAge: nat;
+   hashVerified: bool;
+   isCurrent: bool;
+   issuedAt: int;
+   titleNumberMatches: bool;
+   verifiedAt: int;
+   verifiedBy: principal;
+ };
+type OSCertificateVerification = 
+ record {
+   advisoryEntries: vec text;
+   daysRemaining: opt int;
+   hashVerified: bool;
+   priorityExpiry: opt int;
+   priorityStatus: PriorityStatus;
+   registerChangedFlag: opt bool;
+   titleNumberMatches: bool;
+   verifiedAt: int;
+   verifiedBy: principal;
+ };
+type LRDocumentType = 
+ variant {
+   AP1Acknowledgement;
+   CompletionConfirmation;
+   LandChargesSearchK16;
+   LocalAuthoritySearch;
+   OfficialCopyRegister;
+   OfficialCopyTitlePlan;
+   OfficialSearchCertificate;
+   RegisterExtract;
+   RequisitionNotice;
+   SearchOfPartCertificate;
+ };
+type LRDocumentSummary = 
+ record {
+   documentType: LRDocumentType;
+   isCurrent: bool;
+   isVerified: bool;
+   landRegistryReference: opt text;
+   validUntil: opt int;
+ };
 type DocumentVerification = 
  record {
    calculatedHash: text;
@@ -45,9 +167,17 @@ type DocumentMetadata =
    uploadedAt: Time;
    uploadedBy: principal;
  };
+type DataMismatch = 
+ record {
+   expected: text;
+   field: text;
+   found: text;
+ };
 type AuditLog = 
  record {
    action: text;
+   actorType: ActorType;
+   delegatedBy: opt principal;
    details: text;
    documentId: nat;
    id: nat;
@@ -55,6 +185,12 @@ type AuditLog =
    success: bool;
    timestamp: Time;
  };
+type ActorType = 
+ variant {
+   agent;
+   systemActor;
+   user;
+ };
 service : {
   deleteDocument: (documentId: nat) -> (variant {
                                           err: text;
@@ -70,6 +206,8 @@ service : {
   getDocument: (id: nat) -> (opt DocumentMetadata) query;
   getDocumentVerifications: (documentId: nat) ->
    (vec DocumentVerification) query;
+  getOscarVerificationDetails: (verificationId: nat) ->
+   (opt OscarVerificationDetails) query;
   getPropertyDocuments: (propertyId: nat) -> (vec DocumentMetadata) query;
   getRecentAuditLogs: (limit: nat) -> (vec AuditLog) query;
   getStats: () ->
@@ -79,10 +217,16 @@ service : {
       totalVerifications: nat;
       verifiedDocuments: nat;
     }) query;
+  getTransactionVerificationSummary: (transactionId: text, titleNumber:
+   text) -> (Result_4);
   getUnverifiedDocuments: (propertyId: nat) -> (vec DocumentMetadata) query;
   getVerification: (verificationId: nat) -> (opt DocumentVerification) query;
+  getVerificationsByTransaction: (txId: nat) ->
+   (vec DocumentVerification) query;
   getVerificationsByVerifier: (verifier: principal) ->
    (vec DocumentVerification) query;
+  recordAuditEntry: (actorType: ActorType, delegatedBy: opt principal,
+   action: text, documentId: nat, details: text, success: bool) -> (Result_3);
   registerDocument: (propertyId: nat, transactionId: opt nat, documentType:
    text, documentHash: text, storageDocumentId: opt nat, fileName: opt text,
    fileSize: opt nat, contentType: opt text) -> (nat);
@@ -90,9 +234,15 @@ service : {
   setUserManagementCanister: (canisterId: principal) -> ();
   verifyDocument: (documentId: nat) -> (bool);
   verifyDocumentWithHash: (documentId: nat, notes: opt text) -> (Result);
+  verifyOfficialCopy: (documentId: nat, expectedTitleNumber: text,
+   maxAgeDays: nat) -> (Result_2);
+  verifyOfficialSearchCertificate: (documentId: nat, expectedTitleNumber:
+   text, _expectedTransactionId: opt text) -> (Result_1);
   verifyWithCommercialAPI: (_documentId: nat, _apiProvider: text,
    _verificationData: text) -> (Result);
   verifyWithDVLA: (_documentId: nat, _drivingLicenseNumber: text) -> (Result);
+  verifyWithOscar: (documentId: nat, oscarResult: OscarVerificationInput) ->
+   (Result);
   verifyWithPassportDCS: (_documentId: nat, _passportNumber: text) ->
    (Result);
 }

package/src/canisters/document_verification/document_verification.did.d.ts

@@ -2,15 +2,25 @@ import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
 import type { IDL } from '@dfinity/candid';
 
+export type ActorType = { 'agent' : null } |
+  { 'systemActor' : null } |
+  { 'user' : null };
 export interface AuditLog {
   'id' : bigint,
   'action' : string,
+  'actorType' : ActorType,
+  'delegatedBy' : [] | [Principal],
   'performedBy' : Principal,
   'timestamp' : Time,
   'details' : string,
   'success' : boolean,
   'documentId' : bigint,
 }
+export interface DataMismatch {
+  'field' : string,
+  'found' : string,
+  'expected' : string,
+}
 export interface DocumentMetadata {
   'id' : bigint,
   'documentHash' : string,
@@ -42,10 +52,105 @@ export interface DocumentVerification {
   'verifiedBy' : Principal,
   'verificationMethod' : VerificationMethod,
 }
+export interface LRDocumentSummary {
+  'documentType' : LRDocumentType,
+  'isVerified' : boolean,
+  'isCurrent' : boolean,
+  'landRegistryReference' : [] | [string],
+  'validUntil' : [] | [bigint],
+}
+export type LRDocumentType = { 'LandChargesSearchK16' : null } |
+  { 'OfficialSearchCertificate' : null } |
+  { 'SearchOfPartCertificate' : null } |
+  { 'RegisterExtract' : null } |
+  { 'OfficialCopyRegister' : null } |
+  { 'LocalAuthoritySearch' : null } |
+  { 'OfficialCopyTitlePlan' : null } |
+  { 'CompletionConfirmation' : null } |
+  { 'AP1Acknowledgement' : null } |
+  { 'RequisitionNotice' : null };
+export interface OSCertificateVerification {
+  'priorityStatus' : PriorityStatus,
+  'registerChangedFlag' : [] | [boolean],
+  'advisoryEntries' : Array<string>,
+  'hashVerified' : boolean,
+  'priorityExpiry' : [] | [bigint],
+  'titleNumberMatches' : boolean,
+  'daysRemaining' : [] | [bigint],
+  'verifiedAt' : bigint,
+  'verifiedBy' : Principal,
+}
+export interface OfficialCopyVerification {
+  'documentAge' : bigint,
+  'hashVerified' : boolean,
+  'issuedAt' : bigint,
+  'titleNumberMatches' : boolean,
+  'isCurrent' : boolean,
+  'copyType' : LRDocumentType,
+  'verifiedAt' : bigint,
+  'verifiedBy' : Principal,
+}
+export interface OscarIssue {
+  'field' : [] | [string],
+  'code' : string,
+  'message' : string,
+  'severity' : { 'warning' : null } |
+    { 'info' : null } |
+    { 'error' : null },
+}
+export interface OscarVerificationDetails {
+  'documentType' : string,
+  'requiresSolicitorReview' : boolean,
+  'extractedData' : string,
+  'issues' : Array<OscarIssue>,
+  'mismatches' : Array<DataMismatch>,
+  'confidence' : bigint,
+  'analysisTimestamp' : Time,
+}
+export interface OscarVerificationInput {
+  'documentType' : string,
+  'requiresSolicitorReview' : boolean,
+  'extractedData' : string,
+  'issues' : Array<OscarIssue>,
+  'mismatches' : Array<DataMismatch>,
+  'confidence' : bigint,
+}
+export type PriorityStatus = { 'Active' : null } |
+  { 'ExpiringImminently' : null } |
+  { 'Unknown' : null } |
+  { 'Expired' : null };
 export type Result = { 'ok' : DocumentVerification } |
   { 'err' : string };
+export type Result_1 = { 'ok' : OSCertificateVerification } |
+  { 'err' : string };
+export type Result_2 = { 'ok' : OfficialCopyVerification } |
+  { 'err' : string };
+export type Result_3 = { 'ok' : bigint } |
+  { 'err' : string };
+export type Result_4 = { 'ok' : TransactionVerificationSummary } |
+  { 'err' : string };
 export type Time = bigint;
-export type VerificationMethod = { 'passport_dcs' : null } |
+export interface TransactionVerificationSummary {
+  'missingDocuments' : Array<string>,
+  'expiredDocuments' : bigint,
+  'hasOfficialSearch' : boolean,
+  'titleNumber' : string,
+  'allDocumentsVerified' : boolean,
+  'readyForSubmission' : boolean,
+  'readyForCompletion' : boolean,
+  'officialSearchValid' : boolean,
+  'allLRDocumentsCurrent' : boolean,
+  'verifiedDocuments' : bigint,
+  'daysUntilSearchExpiry' : [] | [bigint],
+  'lrDocuments' : Array<LRDocumentSummary>,
+  'officialSearchExpiry' : [] | [bigint],
+  'readyForExchange' : boolean,
+  'unverifiedDocuments' : bigint,
+  'totalDocuments' : bigint,
+  'transactionId' : string,
+}
+export type VerificationMethod = { 'oscar_ai' : OscarVerificationDetails } |
+  { 'passport_dcs' : null } |
   { 'commercial_api' : string } |
   { 'system_hash_only' : null } |
   { 'manual_solicitor' : null } |
@@ -70,6 +175,10 @@ export interface _SERVICE {
     [bigint],
     Array<DocumentVerification>
   >,
+  'getOscarVerificationDetails' : ActorMethod<
+    [bigint],
+    [] | [OscarVerificationDetails]
+  >,
   'getPropertyDocuments' : ActorMethod<[bigint], Array<DocumentMetadata>>,
   'getRecentAuditLogs' : ActorMethod<[bigint], Array<AuditLog>>,
   'getStats' : ActorMethod<
@@ -81,12 +190,21 @@ export interface _SERVICE {
       'totalDocuments' : bigint,
     }
   >,
+  'getTransactionVerificationSummary' : ActorMethod<[string, string], Result_4>,
   'getUnverifiedDocuments' : ActorMethod<[bigint], Array<DocumentMetadata>>,
   'getVerification' : ActorMethod<[bigint], [] | [DocumentVerification]>,
+  'getVerificationsByTransaction' : ActorMethod<
+    [bigint],
+    Array<DocumentVerification>
+  >,
   'getVerificationsByVerifier' : ActorMethod<
     [Principal],
     Array<DocumentVerification>
   >,
+  'recordAuditEntry' : ActorMethod<
+    [ActorType, [] | [Principal], string, bigint, string, boolean],
+    Result_3
+  >,
   'registerDocument' : ActorMethod<
     [
       bigint,
@@ -104,8 +222,14 @@ export interface _SERVICE {
   'setUserManagementCanister' : ActorMethod<[Principal], undefined>,
   'verifyDocument' : ActorMethod<[bigint], boolean>,
   'verifyDocumentWithHash' : ActorMethod<[bigint, [] | [string]], Result>,
+  'verifyOfficialCopy' : ActorMethod<[bigint, string, bigint], Result_2>,
+  'verifyOfficialSearchCertificate' : ActorMethod<
+    [bigint, string, [] | [string]],
+    Result_1
+  >,
   'verifyWithCommercialAPI' : ActorMethod<[bigint, string, string], Result>,
   'verifyWithDVLA' : ActorMethod<[bigint, string], Result>,
+  'verifyWithOscar' : ActorMethod<[bigint, OscarVerificationInput], Result>,
   'verifyWithPassportDCS' : ActorMethod<[bigint, string], Result>,
 }
 export declare const idlFactory: IDL.InterfaceFactory;

package/src/canisters/document_verification/document_verification.did.js

@@ -1,8 +1,15 @@
 export const idlFactory = ({ IDL }) => {
+  const ActorType = IDL.Variant({
+    'agent' : IDL.Null,
+    'systemActor' : IDL.Null,
+    'user' : IDL.Null,
+  });
   const Time = IDL.Int;
   const AuditLog = IDL.Record({
     'id' : IDL.Nat,
     'action' : IDL.Text,
+    'actorType' : ActorType,
+    'delegatedBy' : IDL.Opt(IDL.Principal),
     'performedBy' : IDL.Principal,
     'timestamp' : Time,
     'details' : IDL.Text,
@@ -24,7 +31,32 @@ export const idlFactory = ({ IDL }) => {
     'uploadedBy' : IDL.Principal,
     'transactionId' : IDL.Opt(IDL.Nat),
   });
+  const OscarIssue = IDL.Record({
+    'field' : IDL.Opt(IDL.Text),
+    'code' : IDL.Text,
+    'message' : IDL.Text,
+    'severity' : IDL.Variant({
+      'warning' : IDL.Null,
+      'info' : IDL.Null,
+      'error' : IDL.Null,
+    }),
+  });
+  const DataMismatch = IDL.Record({
+    'field' : IDL.Text,
+    'found' : IDL.Text,
+    'expected' : IDL.Text,
+  });
+  const OscarVerificationDetails = IDL.Record({
+    'documentType' : IDL.Text,
+    'requiresSolicitorReview' : IDL.Bool,
+    'extractedData' : IDL.Text,
+    'issues' : IDL.Vec(OscarIssue),
+    'mismatches' : IDL.Vec(DataMismatch),
+    'confidence' : IDL.Nat,
+    'analysisTimestamp' : Time,
+  });
   const VerificationMethod = IDL.Variant({
+    'oscar_ai' : OscarVerificationDetails,
     'passport_dcs' : IDL.Null,
     'commercial_api' : IDL.Text,
     'system_hash_only' : IDL.Null,
@@ -47,7 +79,93 @@ export const idlFactory = ({ IDL }) => {
     'verifiedBy' : IDL.Principal,
     'verificationMethod' : VerificationMethod,
   });
+  const LRDocumentType = IDL.Variant({
+    'LandChargesSearchK16' : IDL.Null,
+    'OfficialSearchCertificate' : IDL.Null,
+    'SearchOfPartCertificate' : IDL.Null,
+    'RegisterExtract' : IDL.Null,
+    'OfficialCopyRegister' : IDL.Null,
+    'LocalAuthoritySearch' : IDL.Null,
+    'OfficialCopyTitlePlan' : IDL.Null,
+    'CompletionConfirmation' : IDL.Null,
+    'AP1Acknowledgement' : IDL.Null,
+    'RequisitionNotice' : IDL.Null,
+  });
+  const LRDocumentSummary = IDL.Record({
+    'documentType' : LRDocumentType,
+    'isVerified' : IDL.Bool,
+    'isCurrent' : IDL.Bool,
+    'landRegistryReference' : IDL.Opt(IDL.Text),
+    'validUntil' : IDL.Opt(IDL.Int),
+  });
+  const TransactionVerificationSummary = IDL.Record({
+    'missingDocuments' : IDL.Vec(IDL.Text),
+    'expiredDocuments' : IDL.Nat,
+    'hasOfficialSearch' : IDL.Bool,
+    'titleNumber' : IDL.Text,
+    'allDocumentsVerified' : IDL.Bool,
+    'readyForSubmission' : IDL.Bool,
+    'readyForCompletion' : IDL.Bool,
+    'officialSearchValid' : IDL.Bool,
+    'allLRDocumentsCurrent' : IDL.Bool,
+    'verifiedDocuments' : IDL.Nat,
+    'daysUntilSearchExpiry' : IDL.Opt(IDL.Int),
+    'lrDocuments' : IDL.Vec(LRDocumentSummary),
+    'officialSearchExpiry' : IDL.Opt(IDL.Int),
+    'readyForExchange' : IDL.Bool,
+    'unverifiedDocuments' : IDL.Nat,
+    'totalDocuments' : IDL.Nat,
+    'transactionId' : IDL.Text,
+  });
+  const Result_4 = IDL.Variant({
+    'ok' : TransactionVerificationSummary,
+    'err' : IDL.Text,
+  });
+  const Result_3 = IDL.Variant({ 'ok' : IDL.Nat, 'err' : IDL.Text });
   const Result = IDL.Variant({ 'ok' : DocumentVerification, 'err' : IDL.Text });
+  const OfficialCopyVerification = IDL.Record({
+    'documentAge' : IDL.Nat,
+    'hashVerified' : IDL.Bool,
+    'issuedAt' : IDL.Int,
+    'titleNumberMatches' : IDL.Bool,
+    'isCurrent' : IDL.Bool,
+    'copyType' : LRDocumentType,
+    'verifiedAt' : IDL.Int,
+    'verifiedBy' : IDL.Principal,
+  });
+  const Result_2 = IDL.Variant({
+    'ok' : OfficialCopyVerification,
+    'err' : IDL.Text,
+  });
+  const PriorityStatus = IDL.Variant({
+    'Active' : IDL.Null,
+    'ExpiringImminently' : IDL.Null,
+    'Unknown' : IDL.Null,
+    'Expired' : IDL.Null,
+  });
+  const OSCertificateVerification = IDL.Record({
+    'priorityStatus' : PriorityStatus,
+    'registerChangedFlag' : IDL.Opt(IDL.Bool),
+    'advisoryEntries' : IDL.Vec(IDL.Text),
+    'hashVerified' : IDL.Bool,
+    'priorityExpiry' : IDL.Opt(IDL.Int),
+    'titleNumberMatches' : IDL.Bool,
+    'daysRemaining' : IDL.Opt(IDL.Int),
+    'verifiedAt' : IDL.Int,
+    'verifiedBy' : IDL.Principal,
+  });
+  const Result_1 = IDL.Variant({
+    'ok' : OSCertificateVerification,
+    'err' : IDL.Text,
+  });
+  const OscarVerificationInput = IDL.Record({
+    'documentType' : IDL.Text,
+    'requiresSolicitorReview' : IDL.Bool,
+    'extractedData' : IDL.Text,
+    'issues' : IDL.Vec(OscarIssue),
+    'mismatches' : IDL.Vec(DataMismatch),
+    'confidence' : IDL.Nat,
+  });
   return IDL.Service({
     'deleteDocument' : IDL.Func(
         [IDL.Nat],
@@ -72,6 +190,11 @@ export const idlFactory = ({ IDL }) => {
         [IDL.Vec(DocumentVerification)],
         ['query'],
       ),
+    'getOscarVerificationDetails' : IDL.Func(
+        [IDL.Nat],
+        [IDL.Opt(OscarVerificationDetails)],
+        ['query'],
+      ),
     'getPropertyDocuments' : IDL.Func(
         [IDL.Nat],
         [IDL.Vec(DocumentMetadata)],
@@ -90,6 +213,11 @@ export const idlFactory = ({ IDL }) => {
         ],
         ['query'],
       ),
+    'getTransactionVerificationSummary' : IDL.Func(
+        [IDL.Text, IDL.Text],
+        [Result_4],
+        [],
+      ),
     'getUnverifiedDocuments' : IDL.Func(
         [IDL.Nat],
         [IDL.Vec(DocumentMetadata)],
@@ -100,11 +228,28 @@ export const idlFactory = ({ IDL }) => {
         [IDL.Opt(DocumentVerification)],
         ['query'],
       ),
+    'getVerificationsByTransaction' : IDL.Func(
+        [IDL.Nat],
+        [IDL.Vec(DocumentVerification)],
+        ['query'],
+      ),
     'getVerificationsByVerifier' : IDL.Func(
         [IDL.Principal],
         [IDL.Vec(DocumentVerification)],
         ['query'],
       ),
+    'recordAuditEntry' : IDL.Func(
+        [
+          ActorType,
+          IDL.Opt(IDL.Principal),
+          IDL.Text,
+          IDL.Nat,
+          IDL.Text,
+          IDL.Bool,
+        ],
+        [Result_3],
+        [],
+      ),
     'registerDocument' : IDL.Func(
         [
           IDL.Nat,
@@ -127,12 +272,27 @@ export const idlFactory = ({ IDL }) => {
         [Result],
         [],
       ),
+    'verifyOfficialCopy' : IDL.Func(
+        [IDL.Nat, IDL.Text, IDL.Nat],
+        [Result_2],
+        [],
+      ),
+    'verifyOfficialSearchCertificate' : IDL.Func(
+        [IDL.Nat, IDL.Text, IDL.Opt(IDL.Text)],
+        [Result_1],
+        [],
+      ),
     'verifyWithCommercialAPI' : IDL.Func(
         [IDL.Nat, IDL.Text, IDL.Text],
         [Result],
         [],
       ),
     'verifyWithDVLA' : IDL.Func([IDL.Nat, IDL.Text], [Result], []),
+    'verifyWithOscar' : IDL.Func(
+        [IDL.Nat, OscarVerificationInput],
+        [Result],
+        [],
+      ),
     'verifyWithPassportDCS' : IDL.Func([IDL.Nat, IDL.Text], [Result], []),
   });
 };

package/src/canisters/email_service/email_service.did

@@ -1,33 +1,82 @@
+type Result_1 = 
+ variant {
+   err: text;
+   ok: nat;
+ };
+type Result = 
+ variant {
+   err: text;
+   ok: text;
+ };
 type EmailNotification = 
  record {
    company: opt text;
    contactType: ContactType;
    email: text;
    id: nat;
+   lrNotificationType: opt text;
    message: text;
    name: text;
    partnerType: opt text;
    phone: opt text;
    processed: bool;
+   propertyAddress: opt text;
    subject: text;
    timestamp: int;
+   titleNumber: opt text;
+   transactionId: opt text;
    userType: opt text;
    volume: opt text;
    website: opt text;
  };
 type ContactType = 
  variant {
+   email_verification;
+   lr_application_registered;
+   lr_application_submitted;
+   lr_budget_alert;
+   lr_official_search_complete;
+   lr_requisition_raised;
+   lr_search_expiry_warning;
+   lr_status_change;
+   message_notification;
    partners;
    sales;
    support;
  };
 service : {
+  checkAndSendExpiryWarnings: (daysThreshold: nat) -> (Result_1);
+  disableExpiryWarningTimer: () -> (Result);
+  enableExpiryWarningTimer: () -> (Result);
   formatNotificationAsEmail: (id: nat) -> (opt text) query;
   getAllNotifications: () -> (vec EmailNotification) query;
+  getCycles: () -> (nat) query;
+  getExpiryWarningStatus: () ->
+   (record {
+      lastCheckTime: int;
+      timerActive: bool;
+    }) query;
+  getLandRegistryNotifications: (txnId: text) ->
+   (vec EmailNotification) query;
   getNotification: (id: nat) -> (opt EmailNotification) query;
+  getTransactionManagerCanister: () -> (text) query;
   getUnprocessedCount: () -> (nat) query;
+  getUnprocessedLRNotifications: () -> (vec EmailNotification) query;
   getUnprocessedNotifications: () -> (vec EmailNotification) query;
+  getUserManagementCanister: () -> (text) query;
   markAsProcessed: (id: nat) -> (bool);
+  sendBudgetAlert: (recipientEmail: text, recipientName: text, currentSpend:
+   nat, budgetLimit: nat, percentUsed: nat) -> (nat);
+  sendLandRegistryNotification: (recipientEmail: text, recipientName: 
+   text, notificationType: text, txnId: text, title: text, propAddress: 
+   text, details: text) -> (nat);
+  setTransactionManagerCanister: (canisterId: text) -> (Result);
+  setUserManagementCanister: (canisterId: text) -> (Result);
+  submitEmailVerification: (name: text, email: text, verificationToken:
+   text) -> (nat);
+  submitMessageNotification: (recipientEmail: text, recipientName: text,
+   senderName: text, subject: text, messagePreview: text, threadId: text,
+   transactionId: text, propertyAddress: text, priority: text) -> (nat);
   submitPartnerInquiry: (name: text, email: text, company: text, website:
    text, partnerType: text, message: text) -> (nat);
   submitSalesInquiry: (name: text, email: text, company: text, phone: