@engramx/idl 0.16.0-rc.1

package/dist/engram.idl.js

@@ -0,0 +1,1423 @@
+export const idlFactory = ({ IDL }) => {
+  const About = IDL.Record({
+    verifiedHuman: IDL.Bool,
+    guardianCount: IDL.Nat,
+    totalMemoryWrites: IDL.Nat,
+    lastAgentWriteAtNs: IDL.Opt(IDL.Int),
+    distinctReaderPrincipals: IDL.Nat,
+    lastWriteAtNs: IDL.Opt(IDL.Int),
+    totalBackupSize: IDL.Nat,
+    backupCount: IDL.Nat,
+    lastAgentReadAtNs: IDL.Opt(IDL.Int),
+    firstWriteAtNs: IDL.Opt(IDL.Int),
+    agentCount: IDL.Nat,
+    paidMemoryReadEnabled: IDL.Bool,
+    version: IDL.Text,
+    paymentsFrozen: IDL.Bool,
+    agentMemoryWrites: IDL.Nat,
+    agentMemoryReads: IDL.Nat,
+    auditLogSize: IDL.Nat,
+    memoryFileCount: IDL.Nat,
+    firstAgentWriteAtNs: IDL.Opt(IDL.Int),
+    lastReadAtNs: IDL.Opt(IDL.Int),
+    writesPaused: IDL.Bool,
+    distinctReaderClients: IDL.Nat,
+    totalMemoryReads: IDL.Nat,
+    walletActivatedAtNs: IDL.Opt(IDL.Int),
+    encryptionEnabled: IDL.Bool,
+    paidMemoryWriteEnabled: IDL.Bool,
+  });
+  const AgentStatus = IDL.Variant({
+    Active: IDL.Null,
+    Resigned: IDL.Null,
+    Revoked: IDL.Null,
+  });
+  const LogPosition = IDL.Record({ reads: IDL.Nat, record: IDL.Nat });
+  const HeldKey = IDL.Record({
+    key: IDL.Principal,
+    from: LogPosition,
+    until: LogPosition,
+  });
+  const AgentPermissions = IDL.Record({
+    canReadMemory: IDL.Bool,
+    scopes: IDL.Opt(IDL.Vec(IDL.Text)),
+    canReadBackup: IDL.Opt(IDL.Bool),
+    callsPerMinute: IDL.Nat,
+    canAppendMemory: IDL.Bool,
+    canReadWallet: IDL.Bool,
+  });
+  const EnrolmentProof = IDL.Record({
+    signature: IDL.Vec(IDL.Nat8),
+    enrolledKey: IDL.Principal,
+    rootPubkey: IDL.Vec(IDL.Nat8),
+    inviteCode: IDL.Text,
+  });
+  const AgentEndReason = IDL.Variant({
+    Resigned: IDL.Null,
+    OwnerRevoked: IDL.Null,
+    Reset: IDL.Null,
+    KillSwitch: IDL.Null,
+    GuardianRevoked: IDL.Null,
+  });
+  const AgentEnding = IDL.Record({
+    day: IDL.Int,
+    reason: AgentEndReason,
+  });
+  const KeyNomination = IDL.Record({ key: IDL.Principal, atNs: IDL.Int });
+  const AgentRecord = IDL.Record({
+    status: AgentStatus,
+    earlierKeys: IDL.Vec(HeldKey),
+    permissions: AgentPermissions,
+    principal: IDL.Principal,
+    keyRotationCount: IDL.Nat,
+    publicKeyHash: IDL.Opt(IDL.Text),
+    pairedAtNs: IDL.Int,
+    enrolment: EnrolmentProof,
+    lastSeenNs: IDL.Int,
+    name: IDL.Text,
+    root: IDL.Principal,
+    ended: IDL.Opt(AgentEnding),
+    keyNomination: IDL.Opt(KeyNomination),
+    keyRotatedAtNs: IDL.Int,
+    keyHeldFrom: LogPosition,
+  });
+  const Error = IDL.Variant({
+    Invalid: IDL.Text,
+    NotFound: IDL.Text,
+    Refused: IDL.Text,
+    Other: IDL.Text,
+    Unavailable: IDL.Text,
+    Conflict: IDL.Text,
+  });
+  const Result_70 = IDL.Variant({ Ok: AgentRecord, Err: Error });
+  const HttpHeader = IDL.Record({ value: IDL.Text, name: IDL.Text });
+  const HttpRequestResult = IDL.Record({
+    status: IDL.Nat,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HttpHeader),
+  });
+  const Eip712Registration = IDL.Record({
+    encodeTypeString: IDL.Text,
+    cooloffEndsAtNs: IDL.Int,
+    typeId: IDL.Vec(IDL.Nat8),
+  });
+  const Result_69 = IDL.Variant({ Ok: Eip712Registration, Err: Error });
+  const Result_68 = IDL.Variant({
+    Ok: IDL.Record({ activatesAtNs: IDL.Int }),
+    Err: Error,
+  });
+  const GuardianPermissions = IDL.Record({
+    canFreezePayments: IDL.Bool,
+    canRevokeAgents: IDL.Bool,
+    scopes: IDL.Opt(IDL.Vec(IDL.Text)),
+    canPauseWrites: IDL.Bool,
+  });
+  const Result_1 = IDL.Variant({ Ok: IDL.Null, Err: Error });
+  const MemorySource = IDL.Variant({
+    sessionTranscript: IDL.Null,
+    human: IDL.Null,
+    fileSync: IDL.Null,
+    agentDerived: IDL.Null,
+    deterministic: IDL.Null,
+  });
+  const WriteReceipt = IDL.Record({
+    seq: IDL.Nat,
+    head: IDL.Vec(IDL.Nat8),
+    version: IDL.Nat,
+  });
+  const Result = IDL.Variant({ Ok: WriteReceipt, Err: Error });
+  const CondenseResult = IDL.Record({
+    seq: IDL.Nat,
+    toSeq: IDL.Nat,
+    opsRoot: IDL.Vec(IDL.Nat8),
+    head: IDL.Vec(IDL.Nat8),
+    fromSeq: IDL.Nat,
+    headAtBoundary: IDL.Vec(IDL.Nat8),
+    newFirstAvailableSeq: IDL.Nat,
+    historyBytesDelta: IDL.Int,
+    opCount: IDL.Nat,
+  });
+  const Result_67 = IDL.Variant({ Ok: CondenseResult, Err: Error });
+  const BackupType = IDL.Variant({
+    PartialSnapshot: IDL.Null,
+    IncrementalDiff: IDL.Null,
+    FullSnapshot: IDL.Null,
+  });
+  const Result_43 = IDL.Variant({ Ok: IDL.Text, Err: Error });
+  const Result_59 = IDL.Variant({ Ok: IDL.Vec(IDL.Nat8), Err: Error });
+  const Result_8 = IDL.Variant({ Ok: IDL.Nat, Err: Error });
+  const MemoryRangeExport = IDL.Record({
+    seq: IDL.Nat,
+    toSeq: IDL.Nat,
+    opsRoot: IDL.Vec(IDL.Nat8),
+    atNs: IDL.Int,
+    head: IDL.Vec(IDL.Nat8),
+    fromSeq: IDL.Nat,
+    authorFilter: IDL.Opt(IDL.Principal),
+  });
+  const Result_66 = IDL.Variant({ Ok: MemoryRangeExport, Err: Error });
+  const AlertConfig = IDL.Record({
+    url: IDL.Opt(IDL.Text),
+    money: IDL.Bool,
+    classes: IDL.Opt(IDL.Vec(IDL.Tuple(IDL.Text, IDL.Bool))),
+    agentWrites: IDL.Bool,
+    guardian: IDL.Bool,
+    approvals: IDL.Bool,
+  });
+  const AlertStatus = IDL.Record({
+    lastDeliveredAtNs: IDL.Opt(IDL.Int),
+    failures: IDL.Nat,
+    totalAudit: IDL.Nat,
+    cursor: IDL.Nat,
+    disabled: IDL.Bool,
+    config: AlertConfig,
+  });
+  const Result_57 = IDL.Variant({ Ok: AlertStatus, Err: Error });
+  const Result_53 = IDL.Variant({
+    Ok: IDL.Record({ paths: IDL.Vec(IDL.Text) }),
+    Err: Error,
+  });
+  const OwnerRow = IDL.Record({
+    pairedDay: IDL.Nat,
+    lastPaymentDay: IDL.Opt(IDL.Nat),
+    root: IDL.Principal,
+    weeks: IDL.Nat64,
+    produced: IDL.Nat,
+    firstPaymentDay: IDL.Opt(IDL.Nat),
+  });
+  const Page_21 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(OwnerRow),
+  });
+  const Result_64 = IDL.Variant({ Ok: Page_21, Err: Error });
+  const Role = IDL.Variant({
+    Anonymous: IDL.Null,
+    Viewer: IDL.Null,
+    Engram: IDL.Null,
+    Root: IDL.Null,
+    Buyer: IDL.Null,
+    WasmAdmin: IDL.Null,
+    Guardian: IDL.Null,
+    Seller: IDL.Null,
+    Admin: IDL.Null,
+    Agent: IDL.Null,
+    Other: IDL.Null,
+    Owner: IDL.Null,
+  });
+  const AuditEntry = IDL.Record({
+    id: IDL.Nat,
+    entryHash: IDL.Vec(IDL.Nat8),
+    callerRole: Role,
+    operation: IDL.Text,
+    details: IDL.Text,
+    caller: IDL.Principal,
+    success: IDL.Bool,
+    timestampNs: IDL.Int,
+  });
+  const AgentWriteRow = IDL.Record({
+    source: IDL.Opt(IDL.Text),
+    path: IDL.Opt(IDL.Text),
+    entry: AuditEntry,
+    version: IDL.Opt(IDL.Nat),
+    connector: IDL.Opt(IDL.Text),
+  });
+  const AgentWriteReview = IDL.Record({
+    cursor: IDL.Nat,
+    head: IDL.Nat,
+    rows: IDL.Vec(AgentWriteRow),
+    earliest: IDL.Nat,
+    capped: IDL.Bool,
+  });
+  const Result_63 = IDL.Variant({ Ok: AgentWriteReview, Err: Error });
+  const AnchorPushStatus = IDL.Record({
+    anchorTickAtNs: IDL.Opt(IDL.Int),
+    okAtNs: IDL.Opt(IDL.Int),
+    cadenceSeconds: IDL.Nat,
+    attemptTotal: IDL.Nat,
+    currentTotal: IDL.Nat,
+    timerTickAtNs: IDL.Opt(IDL.Int),
+    okTotal: IDL.Nat,
+    carrierArmedAtNs: IDL.Int,
+    attemptAtNs: IDL.Opt(IDL.Int),
+    skipCursor: IDL.Nat,
+    lastError: IDL.Text,
+  });
+  const AuditHead = IDL.Record({
+    headHash: IDL.Vec(IDL.Nat8),
+    size: IDL.Nat,
+  });
+  const BackupStatus = IDL.Variant({
+    Uploading: IDL.Null,
+    Failed: IDL.Null,
+    Finalized: IDL.Null,
+  });
+  const BackupMetadata = IDL.Record({
+    status: BackupStatus,
+    sha256: IDL.Text,
+    backupId: IDL.Text,
+    createdBy: IDL.Principal,
+    createdAtNs: IDL.Int,
+    totalSize: IDL.Nat,
+    backupLabel: IDL.Opt(IDL.Text),
+    backupType: BackupType,
+    dbType: IDL.Text,
+    chunkCount: IDL.Nat,
+    parentBackupId: IDL.Opt(IDL.Text),
+  });
+  const Result_62 = IDL.Variant({ Ok: BackupMetadata, Err: Error });
+  const CertifiedAuditHead = IDL.Record({
+    total: IDL.Nat,
+    certificate: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    headHash: IDL.Vec(IDL.Nat8),
+    size: IDL.Nat,
+    witness: IDL.Opt(IDL.Vec(IDL.Nat8)),
+  });
+  const ChildAllowanceRow = IDL.Record({
+    root: IDL.Principal,
+    remaining: IDL.Nat,
+  });
+  const Result_61 = IDL.Variant({ Ok: ChildAllowanceRow, Err: Error });
+  const ChildOpening = IDL.Record({
+    attachCycles: IDL.Nat,
+    balance: IDL.Nat,
+    allowances: IDL.Vec(ChildAllowanceRow),
+    floorCycles: IDL.Nat,
+  });
+  const Result_60 = IDL.Variant({ Ok: ChildOpening, Err: Error });
+  const ServiceEntry = IDL.Record({
+    endpoint: IDL.Text,
+    name: IDL.Text,
+    version: IDL.Text,
+    domains: IDL.Vec(IDL.Text),
+    skills: IDL.Vec(IDL.Text),
+  });
+  const AgentCard = IDL.Record({
+    x402Support: IDL.Bool,
+    name: IDL.Text,
+    description: IDL.Text,
+    services: IDL.Vec(ServiceEntry),
+  });
+  const EvmAddresses = IDL.Record({
+    pay: IDL.Text,
+    engramRegistration: IDL.Text,
+  });
+  const Result_58 = IDL.Variant({ Ok: EvmAddresses, Err: Error });
+  const GenesisNote = IDL.Record({
+    predecessorSize: IDL.Opt(IDL.Nat),
+    predecessorHeadHash: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    note: IDL.Text,
+    version: IDL.Text,
+    genesisAtNs: IDL.Int,
+  });
+  const MemoryEviction = IDL.Record({
+    evictSeq: IDL.Nat,
+    fromVersion: IDL.Nat,
+    evictedRoot: IDL.Vec(IDL.Nat8),
+    trigger: IDL.Variant({
+      globalCap: IDL.Null,
+      thinTail: IDL.Null,
+      perFileCap: IDL.Null,
+      thinLogSpaced: IDL.Null,
+      policy: IDL.Null,
+    }),
+    cause: IDL.Variant({ maxVersions: IDL.Null, maxBytes: IDL.Null }),
+    toVersion: IDL.Nat,
+  });
+  const MemoryVersionSummary = IDL.Record({
+    by: IDL.Principal,
+    seq: IDL.Nat,
+    contentRoot: IDL.Vec(IDL.Nat8),
+    atNs: IDL.Int,
+    kind: IDL.Variant({
+      set: IDL.Null,
+      restore: IDL.Null,
+      append: IDL.Null,
+      tombstone: IDL.Null,
+    }),
+    size: IDL.Nat,
+    version: IDL.Nat,
+  });
+  const MemoryHistory = IDL.Record({
+    evictions: IDL.Vec(MemoryEviction),
+    oldestRetainedVersion: IDL.Nat,
+    everCount: IDL.Nat,
+    retainedCount: IDL.Nat,
+    versions: IDL.Vec(MemoryVersionSummary),
+    evictedCount: IDL.Nat,
+  });
+  const Result_56 = IDL.Variant({ Ok: MemoryHistory, Err: Error });
+  const MemoryMaintainStatus = IDL.Record({
+    attachOk: IDL.Bool,
+    attachDetail: IDL.Text,
+    totalEvictions: IDL.Nat,
+    refusedQuota: IDL.Text,
+    more: IDL.Bool,
+    lastEvictions: IDL.Nat,
+    lastScrubbed: IDL.Nat,
+    lastMaintainAtNs: IDL.Opt(IDL.Int),
+    totalFindings: IDL.Nat,
+    refused: IDL.Bool,
+  });
+  const RetentionClassSpec = IDL.Variant({
+    vault: IDL.Null,
+    working: IDL.Record({
+      maxVersions: IDL.Opt(IDL.Nat),
+      maxBytes: IDL.Opt(IDL.Nat),
+      thinning: IDL.Variant({
+        tail: IDL.Null,
+        logSpaced: IDL.Record({ denseTail: IDL.Nat }),
+      }),
+    }),
+  });
+  const MemoryRetentionPolicy = IDL.Record({
+    entries: IDL.Vec(IDL.Tuple(IDL.Text, RetentionClassSpec)),
+    guards: IDL.Vec(IDL.Record({ notBeforeNs: IDL.Int, prefix: IDL.Text })),
+  });
+  const Result_55 = IDL.Variant({
+    Ok: MemoryRetentionPolicy,
+    Err: Error,
+  });
+  const GuardianStatus = IDL.Variant({
+    Active: IDL.Null,
+    Pending: IDL.Null,
+  });
+  const GuardianRecord = IDL.Record({
+    status: GuardianStatus,
+    permissions: GuardianPermissions,
+    principal: IDL.Principal,
+    name: IDL.Text,
+    addedAtNs: IDL.Int,
+  });
+  const Result_15 = IDL.Variant({ Ok: GuardianRecord, Err: Error });
+  const OwnerConsole = IDL.Record({
+    pendingApprovalCount: IDL.Nat,
+    memoryKeyEpoch: IDL.Nat,
+    owner: IDL.Opt(IDL.Principal),
+    agentRevisablePathCount: IDL.Nat,
+    protectedPathCount: IDL.Nat,
+    cyclesBalance: IDL.Nat,
+    unknownSessionRefusals: IDL.Nat,
+  });
+  const Result_54 = IDL.Variant({ Ok: OwnerConsole, Err: Error });
+  const SigningFloorStatus = IDL.Record({
+    floor: IDL.Nat,
+    signaturesAboveFloor: IDL.Nat,
+    balance: IDL.Nat,
+    perSignature: IDL.Nat,
+  });
+  const Result_52 = IDL.Variant({ Ok: SigningFloorStatus, Err: Error });
+  const SpendCeiling = IDL.Record({
+    spentToday: IDL.Nat,
+    maxPerDay: IDL.Opt(IDL.Nat),
+  });
+  const Result_51 = IDL.Variant({ Ok: SpendCeiling, Err: Error });
+  const SpendingPolicy = IDL.Record({
+    maxSessionDeposit: IDL.Opt(IDL.Nat),
+    blockedCallers: IDL.Opt(IDL.Vec(IDL.Principal)),
+    maxPerDay: IDL.Opt(IDL.Nat),
+    maxSessionDuration: IDL.Opt(IDL.Int),
+    sessionIdleTimeout: IDL.Opt(IDL.Int),
+    rateLimitPerMinute: IDL.Opt(IDL.Nat),
+    maxPerTransaction: IDL.Opt(IDL.Nat),
+    allowedCallers: IDL.Opt(IDL.Vec(IDL.Principal)),
+    maxConcurrentSessions: IDL.Opt(IDL.Nat),
+  });
+  const Result_50 = IDL.Variant({ Ok: SpendingPolicy, Err: Error });
+  const StorageReport = IDL.Record({
+    sessionFilesSize: IDL.Nat,
+    totalFiles: IDL.Nat,
+    memoryFilesSize: IDL.Nat,
+    totalContentSize: IDL.Nat,
+    backupCount: IDL.Nat,
+    memoryFilesCount: IDL.Nat,
+    versionHistorySize: IDL.Nat,
+    fileLimit: IDL.Nat,
+    backupSize: IDL.Nat,
+    auditLogSize: IDL.Nat,
+    versionHistoryCount: IDL.Nat,
+    sessionFilesCount: IDL.Nat,
+  });
+  const Result_49 = IDL.Variant({ Ok: StorageReport, Err: Error });
+  const TimerHealth = IDL.Record({
+    jobExpiryFastMode: IDL.Bool,
+    jobExpiryArmed: IDL.Bool,
+    alertTimerArmed: IDL.Bool,
+    sessionExpiryArmed: IDL.Bool,
+  });
+  const WalletBalances = IDL.Record({
+    icpE8s: IDL.Nat,
+    ckusdcE6s: IDL.Nat,
+    ckusdtE6s: IDL.Nat,
+    cycles: IDL.Nat,
+  });
+  const Result_48 = IDL.Variant({ Ok: WalletBalances, Err: Error });
+  const WorldIdConfig = IDL.Record({
+    action: IDL.Text,
+    appId: IDL.Text,
+    rpId: IDL.Text,
+    configured: IDL.Bool,
+  });
+  const Result_47 = IDL.Variant({ Ok: WorldIdConfig, Err: Error });
+  const WorldIdRpContext = IDL.Record({
+    signature: IDL.Text,
+    expiresAt: IDL.Nat,
+    createdAt: IDL.Nat,
+    rpId: IDL.Text,
+    nonce: IDL.Text,
+  });
+  const Result_46 = IDL.Variant({ Ok: WorldIdRpContext, Err: Error });
+  const Result_45 = IDL.Variant({ Ok: IDL.Opt(IDL.Text), Err: Error });
+  const HttpRequest = IDL.Record({
+    url: IDL.Text,
+    method: IDL.Text,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+  });
+  const HttpResponse = IDL.Record({
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+    upgrade: IDL.Opt(IDL.Bool),
+    status_code: IDL.Nat16,
+  });
+  const Result_44 = IDL.Variant({ Ok: IDL.Bool, Err: Error });
+  const ActivitySnapshot = IDL.Record({
+    atNs: IDL.Int,
+    memoryReads: IDL.Nat,
+    memoryWrites: IDL.Nat,
+  });
+  const Page_20 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(ActivitySnapshot),
+  });
+  const Result_42 = IDL.Variant({ Ok: Page_20, Err: Error });
+  const Page_19 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(AgentRecord),
+  });
+  const Result_41 = IDL.Variant({ Ok: Page_19, Err: Error });
+  const Page_18 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(
+      IDL.Record({
+        status: AgentStatus,
+        principal: IDL.Principal,
+        name: IDL.Text,
+      }),
+    ),
+  });
+  const Result_40 = IDL.Variant({ Ok: Page_18, Err: Error });
+  const ApprovalStatus = IDL.Variant({
+    Used: IDL.Null,
+    Approved: IDL.Null,
+    Denied: IDL.Null,
+    Expired: IDL.Null,
+    Pending: IDL.Null,
+  });
+  const ApprovalRequest = IDL.Record({
+    id: IDL.Text,
+    expiresAtNs: IDL.Int,
+    status: ApprovalStatus,
+    denialReason: IDL.Opt(IDL.Text),
+    policyField: IDL.Text,
+    approvedBy: IDL.Opt(IDL.Principal),
+    createdAtNs: IDL.Int,
+    approvedAtNs: IDL.Opt(IDL.Int),
+    binding: IDL.Text,
+    operation: IDL.Text,
+    rationale: IDL.Text,
+    policyLimit: IDL.Nat,
+    caller: IDL.Principal,
+    amount: IDL.Nat,
+  });
+  const Page_6 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(ApprovalRequest),
+  });
+  const Result_28 = IDL.Variant({ Ok: Page_6, Err: Error });
+  const Page_1 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(AuditEntry),
+  });
+  const Result_23 = IDL.Variant({ Ok: Page_1, Err: Error });
+  const Page_17 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(BackupMetadata),
+  });
+  const Result_39 = IDL.Variant({ Ok: Page_17, Err: Error });
+  const BearerTokenStatus = IDL.Variant({
+    Active: IDL.Null,
+    Revoked: IDL.Null,
+    Expired: IDL.Null,
+  });
+  const BearerToken = IDL.Record({
+    expiresAtNs: IDL.Int,
+    status: BearerTokenStatus,
+    lastUsedNs: IDL.Int,
+    permissions: AgentPermissions,
+    tokenId: IDL.Text,
+    clientLabel: IDL.Text,
+    issuedAtNs: IDL.Int,
+    tokenHash: IDL.Text,
+    issuedBy: IDL.Principal,
+  });
+  const Page_16 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(BearerToken),
+  });
+  const Result_38 = IDL.Variant({ Ok: Page_16, Err: Error });
+  const CondenseCheckpointRow = IDL.Record({
+    by: IDL.Principal,
+    seq: IDL.Nat,
+    toSeq: IDL.Nat,
+    opsRoot: IDL.Vec(IDL.Nat8),
+    atNs: IDL.Int,
+    fromSeq: IDL.Nat,
+    headAtBoundary: IDL.Vec(IDL.Nat8),
+    opCount: IDL.Nat,
+  });
+  const Page_15 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(CondenseCheckpointRow),
+  });
+  const CheckpointPage = IDL.Record({
+    firstAvailableSeq: IDL.Nat,
+    page: Page_15,
+    scannedThroughSeq: IDL.Nat,
+  });
+  const Result_37 = IDL.Variant({ Ok: CheckpointPage, Err: Error });
+  const CycleSnapshot = IDL.Record({
+    seq: IDL.Nat,
+    source: IDL.Variant({ balance: IDL.Null, self: IDL.Null }),
+    atNs: IDL.Int,
+    cycles: IDL.Nat,
+  });
+  const Page_14 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(CycleSnapshot),
+  });
+  const Result_36 = IDL.Variant({ Ok: Page_14, Err: Error });
+  const Page_13 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(IDL.Text),
+  });
+  const Result_35 = IDL.Variant({ Ok: Page_13, Err: Error });
+  const AuthorityClass = IDL.Variant({
+    standingAuthority: IDL.Null,
+    valueBearing: IDL.Null,
+    standard: IDL.Null,
+  });
+  const RegisteredType = IDL.Record({
+    primaryType: IDL.Text,
+    encodeTypeString: IDL.Text,
+    cooloffEndsAtNs: IDL.Int,
+    domainName: IDL.Text,
+    typeId: IDL.Vec(IDL.Nat8),
+    verifyingContract: IDL.Text,
+    dailySignCap: IDL.Nat,
+    fields: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+    domainSeparator: IDL.Vec(IDL.Nat8),
+    destinationFields: IDL.Vec(IDL.Text),
+    authorityClass: AuthorityClass,
+    typeHash: IDL.Vec(IDL.Nat8),
+    registeredAtNs: IDL.Int,
+    chainId: IDL.Nat,
+    domainVersion: IDL.Text,
+    ackIrrevocable: IDL.Bool,
+  });
+  const Page_12 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(RegisteredType),
+  });
+  const Result_34 = IDL.Variant({ Ok: Page_12, Err: Error });
+  const Page_11 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(IDL.Record({ activeFromNs: IDL.Int, address: IDL.Text })),
+  });
+  const Result_33 = IDL.Variant({ Ok: Page_11, Err: Error });
+  const Page_10 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(GuardianRecord),
+  });
+  const Result_32 = IDL.Variant({ Ok: Page_10, Err: Error });
+  const ExportReceiptRow = IDL.Record({
+    by: IDL.Principal,
+    seq: IDL.Nat,
+    toSeq: IDL.Nat,
+    opsRoot: IDL.Vec(IDL.Nat8),
+    atNs: IDL.Int,
+    fromSeq: IDL.Nat,
+    authorFilter: IDL.Opt(IDL.Principal),
+  });
+  const Page_9 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(ExportReceiptRow),
+  });
+  const ReceiptPage = IDL.Record({
+    firstAvailableSeq: IDL.Nat,
+    page: Page_9,
+    scannedThroughSeq: IDL.Nat,
+  });
+  const Result_31 = IDL.Variant({ Ok: ReceiptPage, Err: Error });
+  const Page_8 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(
+      IDL.Record({
+        path: IDL.Text,
+        version: IDL.Nat,
+        lastModifiedAtNs: IDL.Int,
+      }),
+    ),
+  });
+  const Result_30 = IDL.Variant({ Ok: Page_8, Err: Error });
+  const MemoryLogChunkRef = IDL.Record({
+    hash: IDL.Vec(IDL.Nat8),
+    size: IDL.Nat,
+    birthSeq: IDL.Nat,
+  });
+  const MemoryLogManifest = IDL.Record({
+    contentRoot: IDL.Vec(IDL.Nat8),
+    totalSize: IDL.Nat,
+    chunks: IDL.Vec(MemoryLogChunkRef),
+  });
+  const MemoryLogImportNote = IDL.Variant({
+    legacyDelete: IDL.Null,
+    legacyTruncated: IDL.Record({
+      prefixHash: IDL.Vec(IDL.Nat8),
+      storedBytes: IDL.Nat,
+    }),
+    legacyGap: IDL.Record({ firstSurviving: IDL.Nat }),
+    legacyUnreconstructable: IDL.Record({
+      contentHash: IDL.Vec(IDL.Nat8),
+      reason: IDL.Text,
+    }),
+    genesis: IDL.Record({ boundTo: IDL.Opt(IDL.Vec(IDL.Nat8)) }),
+  });
+  const MemoryLogOp = IDL.Variant({
+    set: IDL.Record({ manifest: MemoryLogManifest }),
+    exported: IDL.Record({
+      toSeq: IDL.Nat,
+      opsRoot: IDL.Vec(IDL.Nat8),
+      fromSeq: IDL.Nat,
+      authorFilter: IDL.Opt(IDL.Principal),
+    }),
+    imported: MemoryLogImportNote,
+    restore: IDL.Record({
+      toVersion: IDL.Nat,
+      manifest: MemoryLogManifest,
+    }),
+    evict: IDL.Record({
+      fromVersion: IDL.Nat,
+      evictedRoot: IDL.Vec(IDL.Nat8),
+      toVersion: IDL.Nat,
+      chunkCount: IDL.Nat,
+      byteCount: IDL.Nat,
+    }),
+    append: IDL.Record({
+      deltaHash: IDL.Vec(IDL.Nat8),
+      deltaSize: IDL.Nat,
+      newSize: IDL.Nat,
+    }),
+    tombstone: IDL.Null,
+    condense: IDL.Record({
+      toSeq: IDL.Nat,
+      opsRoot: IDL.Vec(IDL.Nat8),
+      fromSeq: IDL.Nat,
+      headAtBoundary: IDL.Vec(IDL.Nat8),
+      opCount: IDL.Nat,
+    }),
+  });
+  const MemoryLogEvent = IDL.Record({
+    by: IDL.Principal,
+    op: MemoryLogOp,
+    seq: IDL.Nat,
+    contentRoot: IDL.Vec(IDL.Nat8),
+    atNs: IDL.Int,
+    path: IDL.Text,
+    prev: IDL.Vec(IDL.Nat8),
+    size: IDL.Nat,
+    version: IDL.Nat,
+  });
+  const Page_7 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(MemoryLogEvent),
+  });
+  const LogPage = IDL.Record({
+    firstAvailableSeq: IDL.Nat,
+    head: IDL.Vec(IDL.Nat8),
+    page: Page_7,
+  });
+  const Result_29 = IDL.Variant({ Ok: LogPage, Err: Error });
+  const EngramSessionStatus = IDL.Variant({
+    closed: IDL.Null,
+    expired: IDL.Null,
+    other: IDL.Text,
+    open: IDL.Null,
+    closing: IDL.Null,
+  });
+  const EngramSessionState = IDL.Record({
+    id: IDL.Text,
+    status: EngramSessionStatus,
+    deposited: IDL.Nat,
+    openedAtNs: IDL.Int,
+    lastActivityAtNs: IDL.Int,
+    consumed: IDL.Nat,
+    voucherCount: IDL.Nat,
+    remaining: IDL.Nat,
+    payer: IDL.Principal,
+  });
+  const Page_5 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(EngramSessionState),
+  });
+  const Result_27 = IDL.Variant({ Ok: Page_5, Err: Error });
+  const OwnershipTransfer = IDL.Record({
+    to: IDL.Principal,
+    atNs: IDL.Int,
+    from: IDL.Opt(IDL.Principal),
+    authorizedBy: IDL.Principal,
+  });
+  const Page_4 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(OwnershipTransfer),
+  });
+  const Result_26 = IDL.Variant({ Ok: Page_4, Err: Error });
+  const MarketplacePaymentSignatures = IDL.Record({
+    marketplace: IDL.Principal,
+    sharedSignedToday: IDL.Nat,
+    limit: IDL.Nat,
+  });
+  const AgentPaymentSignatures = IDL.Record({
+    agent: IDL.Principal,
+    signedToday: IDL.Nat,
+    root: IDL.Principal,
+  });
+  const Page_3 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(AgentPaymentSignatures),
+  });
+  const PaymentSignatureCounts = IDL.Record({
+    day: IDL.Int,
+    marketplace: IDL.Opt(MarketplacePaymentSignatures),
+    agents: Page_3,
+    limit: IDL.Nat,
+  });
+  const Result_25 = IDL.Variant({
+    Ok: PaymentSignatureCounts,
+    Err: Error,
+  });
+  const PurgedAgent = IDL.Record({
+    principal: IDL.Principal,
+    pairedAtNs: IDL.Int,
+    name: IDL.Text,
+    root: IDL.Principal,
+    enrolledKey: IDL.Principal,
+    ended: AgentEnding,
+    invite: IDL.Text,
+    purgedAtNs: IDL.Int,
+  });
+  const Page_2 = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(PurgedAgent),
+  });
+  const Result_24 = IDL.Variant({ Ok: Page_2, Err: Error });
+  const Repudiation = IDL.Record({
+    atNs: IDL.Int,
+    path: IDL.Text,
+    auditId: IDL.Nat,
+    version: IDL.Nat,
+    reason: IDL.Text,
+  });
+  const Page = IDL.Record({
+    total: IDL.Nat,
+    withheld: IDL.Nat,
+    items: IDL.Vec(Repudiation),
+  });
+  const Result_22 = IDL.Variant({ Ok: Page, Err: Error });
+  const Result_21 = IDL.Variant({ Ok: IDL.Principal, Err: Error });
+  const SessionConfig = IDL.Record({
+    autoClose: IDL.Bool,
+    idleTimeout: IDL.Opt(IDL.Int),
+    maxDeposit: IDL.Nat,
+  });
+  const Eip3009Authorization = IDL.Record({
+    r: IDL.Vec(IDL.Nat8),
+    s: IDL.Vec(IDL.Nat8),
+    v: IDL.Nat8,
+    to: IDL.Text,
+    value: IDL.Nat,
+    from: IDL.Text,
+    validAfter: IDL.Nat,
+    nonce: IDL.Vec(IDL.Nat8),
+    validBefore: IDL.Nat,
+  });
+  const PaymentSignature = IDL.Record({
+    signature: IDL.Vec(IDL.Nat8),
+    asset: IDL.Opt(IDL.Text),
+    publicKey: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    scheme: IDL.Text,
+    network: IDL.Text,
+    sender: IDL.Text,
+    nonce: IDL.Vec(IDL.Nat8),
+    authorization: IDL.Opt(Eip3009Authorization),
+  });
+  const Result_20 = IDL.Variant({ Ok: EngramSessionState, Err: Error });
+  const TokenAmount = IDL.Variant({
+    Icp: IDL.Nat,
+    Ckusdc: IDL.Nat,
+    Ckusdt: IDL.Nat,
+  });
+  const ActionAuth = IDL.Record({
+    signature: IDL.Vec(IDL.Nat8),
+    pubkey: IDL.Vec(IDL.Nat8),
+    nonce: IDL.Nat,
+  });
+  const Enrolment = IDL.Record({
+    signature: IDL.Vec(IDL.Nat8),
+    enrolledKey: IDL.Principal,
+    rootPubkey: IDL.Vec(IDL.Nat8),
+    engram: IDL.Principal,
+  });
+  const TrackRecordNotice = IDL.Variant({
+    Recorded: IDL.Null,
+    NotRecorded: IDL.Text,
+  });
+  const Pairing = IDL.Record({
+    agent: AgentRecord,
+    trackRecord: TrackRecordNotice,
+  });
+  const Result_19 = IDL.Variant({ Ok: Pairing, Err: Error });
+  const CondensePreview = IDL.Record({
+    scannedFromSeq: IDL.Nat,
+    scanTruncated: IDL.Bool,
+    firstAvailableSeq: IDL.Nat,
+    unlocked: IDL.Bool,
+    totalEvents: IDL.Nat,
+    maxUnlockableToSeq: IDL.Nat,
+    bestUnfilteredReceipt: IDL.Opt(IDL.Record({ seq: IDL.Nat, toSeq: IDL.Nat, fromSeq: IDL.Nat })),
+    opCountInRange: IDL.Nat,
+    filteredReceiptsSeen: IDL.Nat,
+    coveringReceipt: IDL.Opt(IDL.Record({ seq: IDL.Nat, toSeq: IDL.Nat, fromSeq: IDL.Nat })),
+    proposedToSeq: IDL.Nat,
+  });
+  const Result_18 = IDL.Variant({ Ok: CondensePreview, Err: Error });
+  const SessionIntent = IDL.Record({
+    token: IDL.Text,
+    costPerCall: IDL.Opt(IDL.Nat),
+    minDeposit: IDL.Opt(IDL.Nat),
+    recipient: IDL.Text,
+    network: IDL.Text,
+    description: IDL.Opt(IDL.Text),
+    expiryNs: IDL.Int,
+    suggestedDeposit: IDL.Nat,
+  });
+  const MemoryFile = IDL.Record({
+    content: IDL.Vec(IDL.Nat8),
+    path: IDL.Text,
+    version: IDL.Nat,
+    lastModifiedBy: IDL.Principal,
+    lastModifiedAtNs: IDL.Int,
+  });
+  const Result_11 = IDL.Variant({ Ok: MemoryFile, Err: Error });
+  const BatchReadItem = IDL.Record({
+    result: IDL.Variant({ Ok: MemoryFile, Err: Error }),
+    path: IDL.Text,
+  });
+  const Result_17 = IDL.Variant({
+    Ok: IDL.Vec(BatchReadItem),
+    Err: Error,
+  });
+  const MemoryByteChunk = IDL.Record({
+    more: IDL.Bool,
+    fileSize: IDL.Nat,
+    bytes: IDL.Vec(IDL.Nat8),
+  });
+  const Result_16 = IDL.Variant({ Ok: MemoryByteChunk, Err: Error });
+  const ResetReport = IDL.Record({
+    agentsRemoved: IDL.Nat,
+    agentsPurged: IDL.Nat,
+    guardiansRemoved: IDL.Nat,
+    filesCleared: IDL.Nat,
+  });
+  const Result_14 = IDL.Variant({ Ok: ResetReport, Err: Error });
+  const UnrecordableEngagement = IDL.Record({
+    principal: IDL.Principal,
+    root: IDL.Principal,
+    ended: AgentEnding,
+    invite: IDL.Text,
+  });
+  const ResyncReport = IDL.Record({
+    startsAcknowledged: IDL.Nat,
+    cannotBeRecorded: IDL.Vec(UnrecordableEngagement),
+    endingsAcknowledged: IDL.Nat,
+    notRecorded: IDL.Vec(
+      IDL.Record({
+        why: IDL.Text,
+        principal: IDL.Principal,
+        root: IDL.Principal,
+        event: IDL.Text,
+      }),
+    ),
+  });
+  const Result_13 = IDL.Variant({ Ok: ResyncReport, Err: Error });
+  const Voucher = IDL.Record({
+    signature: IDL.Vec(IDL.Nat8),
+    sessionId: IDL.Text,
+    sequence: IDL.Nat,
+    cumulativeAmount: IDL.Nat,
+  });
+  const SessionContext = IDL.Record({
+    files: IDL.Vec(MemoryFile),
+    totalFiles: IDL.Nat,
+    truncated: IDL.Bool,
+    includedFiles: IDL.Nat,
+    totalBytes: IDL.Nat,
+  });
+  const Result_12 = IDL.Variant({ Ok: SessionContext, Err: Error });
+  const BackupRetentionReport = IDL.Record({
+    maxBackups: IDL.Nat,
+    dbType: IDL.Text,
+    prunedBackups: IDL.Nat,
+  });
+  const Result_10 = IDL.Variant({
+    Ok: BackupRetentionReport,
+    Err: Error,
+  });
+  const Eip712Value = IDL.Variant({
+    string: IDL.Text,
+    bool: IDL.Bool,
+    uint: IDL.Nat,
+    address: IDL.Text,
+    fixedBytes: IDL.Vec(IDL.Nat8),
+    bytes: IDL.Vec(IDL.Nat8),
+  });
+  const Eip712SignatureOut = IDL.Record({
+    r: IDL.Vec(IDL.Nat8),
+    s: IDL.Vec(IDL.Nat8),
+    v: IDL.Nat8,
+    rendered: IDL.Text,
+    digest: IDL.Vec(IDL.Nat8),
+  });
+  const Result_4 = IDL.Variant({ Ok: Eip712SignatureOut, Err: Error });
+  const SignedTransaction = IDL.Record({
+    txHash: IDL.Text,
+    rawTx: IDL.Text,
+  });
+  const Result_9 = IDL.Variant({ Ok: SignedTransaction, Err: Error });
+  const SignedAuthorization = IDL.Record({
+    paidAmount: IDL.Nat,
+    authorization: IDL.Record({
+      to: IDL.Text,
+      signature: IDL.Text,
+      value: IDL.Nat,
+      from: IDL.Text,
+      validAfter: IDL.Nat,
+      nonce: IDL.Text,
+      validBefore: IDL.Nat,
+    }),
+    header: IDL.Text,
+  });
+  const X402SignOutcome = IDL.Variant({
+    ApprovalPending: ApprovalRequest,
+    Signed: SignedAuthorization,
+  });
+  const Result_3 = IDL.Variant({ Ok: X402SignOutcome, Err: Error });
+  const Seat = IDL.Record({
+    pairedDay: IDL.Nat,
+    lastPaymentDay: IDL.Opt(IDL.Nat),
+    weeks: IDL.Nat64,
+    produced: IDL.Nat,
+    firstPaymentDay: IDL.Opt(IDL.Nat),
+  });
+  const Result_7 = IDL.Variant({ Ok: IDL.Vec(Seat), Err: Error });
+  const RailHealth = IDL.Record({
+    sessionsExpired: IDL.Nat,
+    sessionsClosed: IDL.Nat,
+    paidVouchersConsumed: IDL.Nat,
+    escrowOpen: IDL.Opt(IDL.Nat),
+    sessionsOpen: IDL.Nat,
+    sessionsClosing: IDL.Nat,
+    cycles: IDL.Nat,
+    sendHeadroom: IDL.Nat,
+    memoryBytes: IDL.Nat,
+    freezeReservation: IDL.Nat,
+    unknownSessionRefusals: IDL.Nat,
+  });
+  const Result_6 = IDL.Variant({ Ok: RailHealth, Err: Error });
+  const CallerSignatureCount = IDL.Record({
+    count: IDL.Nat,
+    role: Role,
+    root: IDL.Opt(IDL.Principal),
+    caller: IDL.Principal,
+  });
+  const SignatureCounts = IDL.Record({
+    total: IDL.Nat,
+    byCaller: IDL.Vec(CallerSignatureCount),
+  });
+  const Result_5 = IDL.Variant({ Ok: SignatureCounts, Err: Error });
+  const ControlHandover = IDL.Variant({
+    MovedByRegistry: IDL.Null,
+    NotHeldHere: IDL.Null,
+    MovedByEngram: IDL.Null,
+  });
+  const Result_2 = IDL.Variant({ Ok: ControlHandover, Err: Error });
+  const Engram = IDL.Service({
+    about: IDL.Func([], [About], ['query']),
+    acceptAgentKeyNomination: IDL.Func([IDL.Principal], [Result_70], []),
+    actionAlertTransform: IDL.Func(
+      [
+        IDL.Record({
+          context: IDL.Vec(IDL.Nat8),
+          response: HttpRequestResult,
+        }),
+      ],
+      [HttpRequestResult],
+      ['query'],
+    ),
+    addEip712Type: IDL.Func(
+      [
+        IDL.Record({
+          primaryType: IDL.Text,
+          canonicalTypeString: IDL.Text,
+          domainName: IDL.Text,
+          verifyingContract: IDL.Text,
+          dailySignCap: IDL.Nat,
+          fields: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+          destinationFields: IDL.Vec(IDL.Text),
+          authorityClass: IDL.Variant({
+            standingAuthority: IDL.Null,
+            valueBearing: IDL.Null,
+            standard: IDL.Null,
+          }),
+          chainId: IDL.Nat,
+          domainVersion: IDL.Text,
+          ackIrrevocable: IDL.Bool,
+        }),
+      ],
+      [Result_69],
+      [],
+    ),
+    addEvmWithdrawDestination: IDL.Func([IDL.Text], [Result_68], []),
+    addGuardian: IDL.Func([IDL.Principal, IDL.Text, GuardianPermissions], [Result_1], []),
+    appendMemory: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8), IDL.Opt(MemorySource)], [Result], []),
+    applyCondense: IDL.Func([IDL.Nat], [Result_67], []),
+    approveGuardian: IDL.Func([IDL.Principal], [Result_1], []),
+    approveRequest: IDL.Func([IDL.Text], [Result_1], []),
+    backupAbort: IDL.Func([IDL.Text], [Result_1], []),
+    backupFinalize: IDL.Func([IDL.Text], [Result_1], []),
+    backupInit: IDL.Func(
+      [IDL.Text, BackupType, IDL.Opt(IDL.Text), IDL.Text, IDL.Opt(IDL.Text)],
+      [Result_43],
+      [],
+    ),
+    backupPullChunk: IDL.Func([IDL.Text, IDL.Nat], [Result_59], ['query']),
+    backupPushChunk: IDL.Func([IDL.Text, IDL.Nat, IDL.Vec(IDL.Nat8)], [Result_1], []),
+    cancelAgentKeyNomination: IDL.Func([IDL.Principal], [Result_1], []),
+    closeSession: IDL.Func([IDL.Text], [Result_1], []),
+    convertEarningsToCycles: IDL.Func([IDL.Text, IDL.Nat], [Result_8], []),
+    createAgentInvite: IDL.Func([IDL.Text, AgentPermissions], [Result_43], []),
+    createGuardianInvite: IDL.Func([IDL.Text, GuardianPermissions], [Result_43], []),
+    deleteBackup: IDL.Func([IDL.Text], [Result_1], []),
+    deleteMemoryFile: IDL.Func([IDL.Text], [Result], []),
+    denyRequest: IDL.Func([IDL.Text, IDL.Text], [Result_1], []),
+    ensureEvmReady: IDL.Func([], [Result_43], []),
+    exportMemoryRange: IDL.Func([IDL.Nat, IDL.Nat, IDL.Opt(IDL.Principal)], [Result_66], []),
+    freezePayments: IDL.Func([], [Result_1], []),
+    getActionAlertStatus: IDL.Func([], [Result_57], ['query']),
+    getAgentRevisablePaths: IDL.Func([], [Result_53], ['query']),
+    getAgentSeatWeeks: IDL.Func([IDL.Nat, IDL.Nat], [Result_64], ['query']),
+    getAgentWriteReview: IDL.Func([], [Result_63], ['query']),
+    getAnchorPushStatus: IDL.Func([], [AnchorPushStatus], ['query']),
+    getAuditHead: IDL.Func([], [AuditHead], ['query']),
+    getBackupMetadata: IDL.Func([IDL.Text], [Result_62], ['query']),
+    getBillerId: IDL.Func([], [IDL.Opt(IDL.Principal)], ['query']),
+    getCertifiedAuditHead: IDL.Func([], [CertifiedAuditHead], ['query']),
+    getChildAllowance: IDL.Func([IDL.Principal], [Result_61], ['query']),
+    getChildOpening: IDL.Func([], [Result_60], ['query']),
+    getEncryptedMemoryKey: IDL.Func([IDL.Opt(IDL.Nat), IDL.Vec(IDL.Nat8)], [Result_59], []),
+    getEngramCard: IDL.Func([], [AgentCard], ['query']),
+    getEngramNumber: IDL.Func([], [IDL.Opt(IDL.Nat)], ['query']),
+    getEvmAddress: IDL.Func([], [Result_58], []),
+    getEvmOwnerAddress: IDL.Func([], [IDL.Opt(IDL.Text)], ['query']),
+    getEvmSignerAddress: IDL.Func([], [Result_43], []),
+    getGenesisNote: IDL.Func([], [GenesisNote], ['query']),
+    getGuardianAlertStatus: IDL.Func([], [Result_57], ['query']),
+    getMarketId: IDL.Func([], [IDL.Opt(IDL.Principal)], ['query']),
+    getMemoryHistory: IDL.Func(
+      [IDL.Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)],
+      [Result_56],
+      ['query'],
+    ),
+    getMemoryKeyEpoch: IDL.Func([], [IDL.Nat], ['query']),
+    getMemoryKeyVerificationKey: IDL.Func([], [IDL.Vec(IDL.Nat8)], []),
+    getMemoryMaintainStatus: IDL.Func([], [MemoryMaintainStatus], ['query']),
+    getMemoryRetentionPolicy: IDL.Func([], [Result_55], ['query']),
+    getMetricsReaderId: IDL.Func([], [IDL.Opt(IDL.Principal)], ['query']),
+    getMyGuardianStatus: IDL.Func([], [Result_15], ['query']),
+    getOwnerConsole: IDL.Func([], [Result_54], ['query']),
+    getProtectedPaths: IDL.Func([], [Result_53], ['query']),
+    getSeatWeeksReadEnabled: IDL.Func([], [IDL.Bool], ['query']),
+    getSigningFloor: IDL.Func([], [Result_52], ['query']),
+    getSpawnedBy: IDL.Func([], [IDL.Opt(IDL.Principal)], ['query']),
+    getSpendCeiling: IDL.Func([], [Result_51], ['query']),
+    getSpendPolicy: IDL.Func([IDL.Opt(IDL.Principal)], [Result_50], ['query']),
+    getStorageStats: IDL.Func([], [Result_49], ['query']),
+    getTimerHealth: IDL.Func([], [TimerHealth], ['query']),
+    getTopUpLimits: IDL.Func(
+      [],
+      [IDL.Record({ cooldownSeconds: IDL.Nat, maxCkusdcE6s: IDL.Nat })],
+      ['query'],
+    ),
+    getWalletBalances: IDL.Func([], [Result_48], []),
+    getWorldIdConfig: IDL.Func([], [Result_47], ['query']),
+    getWorldIdRpContext: IDL.Func([], [Result_46], []),
+    getWorldIdRpSignerAddress: IDL.Func([], [Result_43], []),
+    getWorldIdVerification: IDL.Func([], [Result_45], ['query']),
+    guardianRevokeAgent: IDL.Func([IDL.Principal], [Result_1], []),
+    http_request: IDL.Func([HttpRequest], [HttpResponse], ['query']),
+    http_request_update: IDL.Func([HttpRequest], [HttpResponse], []),
+    icrc21_canister_call_consent_message: IDL.Func(
+      [
+        IDL.Record({
+          arg: IDL.Vec(IDL.Nat8),
+          method: IDL.Text,
+          user_preferences: IDL.Record({}),
+        }),
+      ],
+      [
+        IDL.Variant({
+          Ok: IDL.Record({
+            metadata: IDL.Record({
+              utc_offset_minutes: IDL.Opt(IDL.Int16),
+              language: IDL.Text,
+            }),
+            consent_message: IDL.Variant({
+              GenericDisplayMessage: IDL.Text,
+            }),
+          }),
+          Err: IDL.Record({
+            description: IDL.Text,
+            error_code: IDL.Nat,
+          }),
+        }),
+      ],
+      ['query'],
+    ),
+    isEvmAddressCached: IDL.Func([], [Result_44], ['query']),
+    issueAuthCode: IDL.Func([IDL.Text, IDL.Text, IDL.Text, IDL.Opt(IDL.Text)], [Result_43], []),
+    listActivitySnapshots: IDL.Func([IDL.Nat, IDL.Nat], [Result_42], ['query']),
+    listAgents: IDL.Func([IDL.Nat, IDL.Nat], [Result_41], ['query']),
+    listAgentsForGuardian: IDL.Func([IDL.Nat, IDL.Nat], [Result_40], ['query']),
+    listApprovalRequests: IDL.Func(
+      [IDL.Opt(ApprovalStatus), IDL.Nat, IDL.Nat],
+      [Result_28],
+      ['query'],
+    ),
+    listAuditEntries: IDL.Func([IDL.Nat, IDL.Nat], [Result_23], ['query']),
+    listBackups: IDL.Func([IDL.Nat, IDL.Nat], [Result_39], ['query']),
+    listBearerTokens: IDL.Func([IDL.Nat, IDL.Nat], [Result_38], ['query']),
+    listCondenseCheckpoints: IDL.Func([IDL.Nat, IDL.Nat], [Result_37], ['query']),
+    listCycleSnapshots: IDL.Func([IDL.Nat, IDL.Nat], [Result_36], ['query']),
+    listDeletedMemoryFiles: IDL.Func([IDL.Nat, IDL.Nat], [Result_35], ['query']),
+    listEip712Types: IDL.Func([IDL.Nat, IDL.Nat], [Result_34], ['query']),
+    listEvmWithdrawDestinations: IDL.Func([IDL.Nat, IDL.Nat], [Result_33], ['query']),
+    listGuardians: IDL.Func([IDL.Nat, IDL.Nat], [Result_32], ['query']),
+    listMemoryExportReceipts: IDL.Func([IDL.Nat, IDL.Nat], [Result_31], ['query']),
+    listMemoryFiles: IDL.Func([IDL.Nat, IDL.Nat], [Result_30], ['query']),
+    listMemoryLog: IDL.Func([IDL.Nat, IDL.Nat, IDL.Opt(IDL.Principal)], [Result_29], ['query']),
+    listMyApprovalRequests: IDL.Func([IDL.Nat, IDL.Nat], [Result_28], ['query']),
+    listMySessions: IDL.Func([IDL.Nat, IDL.Nat], [Result_27], ['query']),
+    listOwnershipTransfers: IDL.Func([IDL.Nat, IDL.Nat], [Result_26], ['query']),
+    listPaymentSignatureCounts: IDL.Func([IDL.Nat, IDL.Nat], [Result_25], ['query']),
+    listPurgedAgents: IDL.Func([IDL.Nat, IDL.Nat], [Result_24], ['query']),
+    listReadLog: IDL.Func([IDL.Opt(IDL.Bool), IDL.Nat, IDL.Nat], [Result_23], ['query']),
+    listRepudiations: IDL.Func([IDL.Nat, IDL.Nat], [Result_22], ['query']),
+    markAgentWritesReviewed: IDL.Func([IDL.Opt(IDL.Nat)], [Result_8], []),
+    nominateAgentKey: IDL.Func([IDL.Principal], [Result_1], []),
+    openChildEngram: IDL.Func([], [Result_21], []),
+    openSession: IDL.Func([SessionConfig, PaymentSignature], [Result_20], []),
+    ownerWithdraw: IDL.Func([TokenAmount, IDL.Opt(ActionAuth)], [Result_8], []),
+    pairAgent: IDL.Func([IDL.Record({ enrolment: Enrolment, code: IDL.Text })], [Result_19], []),
+    pauseWrites: IDL.Func([], [Result_1], []),
+    previewCondense: IDL.Func([IDL.Nat], [Result_18], ['query']),
+    previewOpenSession: IDL.Func([], [SessionIntent], ['query']),
+    readMemory: IDL.Func([IDL.Text], [Result_11], ['query']),
+    readMemoryBatch: IDL.Func([IDL.Vec(IDL.Text)], [Result_17], ['query']),
+    readMemoryBytes: IDL.Func(
+      [IDL.Text, IDL.Nat, IDL.Nat, IDL.Opt(IDL.Nat)],
+      [Result_16],
+      ['query'],
+    ),
+    recoverEscrow: IDL.Func([IDL.Text, IDL.Nat], [Result_8], []),
+    registerGuardian: IDL.Func([IDL.Text], [Result_15], []),
+    removeCallerSpendPolicy: IDL.Func([IDL.Principal], [Result_1], []),
+    removeEip712Type: IDL.Func([IDL.Vec(IDL.Nat8)], [Result_1], []),
+    removeEvmWithdrawDestination: IDL.Func([IDL.Text], [Result_1], []),
+    removeGuardian: IDL.Func([IDL.Principal], [Result_1], []),
+    repudiateMemoryWrite: IDL.Func([IDL.Text, IDL.Nat, IDL.Text], [Result_8], []),
+    resetEngram: IDL.Func([], [Result_14], []),
+    resignAgent: IDL.Func([], [Result_1], []),
+    resumeWrites: IDL.Func([], [Result_1], []),
+    resyncAgentEdges: IDL.Func([], [Result_13], []),
+    returnToManaged: IDL.Func([], [Result_1], []),
+    reviseMemory: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [Result], []),
+    revokeAgent: IDL.Func([IDL.Principal], [Result_1], []),
+    revokeAllAgents: IDL.Func([], [Result_8], []),
+    revokeAllBearerTokens: IDL.Func([], [Result_8], []),
+    revokeAllInvites: IDL.Func([], [Result_8], []),
+    revokeBearerToken: IDL.Func([IDL.Text], [Result_1], []),
+    rollbackMemory: IDL.Func([IDL.Text, IDL.Nat], [Result], []),
+    rotateAgentKeyHash: IDL.Func([IDL.Text], [Result_1], []),
+    seedMemory: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [Result], []),
+    sessionAppendMemory: IDL.Func([Voucher, IDL.Text, IDL.Vec(IDL.Nat8)], [Result], []),
+    sessionReadContext: IDL.Func([IDL.Text], [Result_12], []),
+    sessionReadMemory: IDL.Func([Voucher, IDL.Text], [Result_11], []),
+    setActionAlertConfig: IDL.Func([AlertConfig], [Result_1], []),
+    setAgentPermissions: IDL.Func([IDL.Principal, AgentPermissions], [Result_1], []),
+    setAgentRevisablePaths: IDL.Func([IDL.Vec(IDL.Text)], [Result_1], []),
+    setBackupRetention: IDL.Func([IDL.Text, IDL.Nat], [Result_10], []),
+    setCallerSpendPolicy: IDL.Func([IDL.Principal, SpendingPolicy], [Result_1], []),
+    setChildAllowance: IDL.Func([IDL.Principal, IDL.Nat], [Result_1], []),
+    setEncryptionEnabled: IDL.Func([IDL.Bool], [Result_1], []),
+    setEvmOwnerAddress: IDL.Func([IDL.Text], [Result_1], []),
+    setGuardianAlertConfig: IDL.Func([AlertConfig], [Result_1], []),
+    setMemoryRetentionPolicy: IDL.Func(
+      [IDL.Vec(IDL.Tuple(IDL.Text, RetentionClassSpec))],
+      [Result_1],
+      [],
+    ),
+    setPaidMemoryReadEnabled: IDL.Func([IDL.Bool], [Result_1], []),
+    setPaidMemoryWriteEnabled: IDL.Func([IDL.Bool], [Result_1], []),
+    setProtectedPaths: IDL.Func([IDL.Vec(IDL.Text)], [Result_1], []),
+    setSeatWeeksReadEnabled: IDL.Func([IDL.Bool], [Result_1], []),
+    setSpendCeiling: IDL.Func([IDL.Opt(IDL.Nat)], [Result_1], []),
+    setSpendPolicy: IDL.Func([SpendingPolicy], [Result_1], []),
+    setTopUpLimits: IDL.Func(
+      [IDL.Record({ cooldownSeconds: IDL.Nat, maxCkusdcE6s: IDL.Nat })],
+      [Result_1],
+      [],
+    ),
+    setWorldIdConfig: IDL.Func([IDL.Text, IDL.Text, IDL.Text], [Result_1], []),
+    setWorldIdProof: IDL.Func([IDL.Text, IDL.Text], [Result_1], []),
+    signEip712: IDL.Func(
+      [IDL.Vec(IDL.Nat8), IDL.Vec(IDL.Tuple(IDL.Text, Eip712Value))],
+      [Result_4],
+      [],
+    ),
+    signEngramRegistration: IDL.Func(
+      [
+        IDL.Record({
+          maxFeePerGas: IDL.Nat,
+          nonce: IDL.Nat,
+          maxPriorityFeePerGas: IDL.Nat,
+        }),
+      ],
+      [Result_9],
+      [],
+    ),
+    signX402Payment: IDL.Func(
+      [
+        IDL.Record({
+          tokenVersion: IDL.Text,
+          tokenAddress: IDL.Text,
+          approvalId: IDL.Opt(IDL.Text),
+          recipient: IDL.Text,
+          rationale: IDL.Opt(IDL.Text),
+          tokenName: IDL.Text,
+          chainId: IDL.Nat,
+          amount: IDL.Nat,
+        }),
+      ],
+      [Result_3],
+      [],
+    ),
+    syncEngramNumber: IDL.Func([], [Result_8], []),
+    sysApplyGenesisSeed: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [Result_8], []),
+    sysForceCloseSession: IDL.Func([IDL.Text], [Result_1], []),
+    sysGetAgentSeatWeeks: IDL.Func([], [Result_7], []),
+    sysGetRailHealth: IDL.Func([], [Result_6], ['query']),
+    sysGetSignatureCounts: IDL.Func([], [Result_5], []),
+    sysNotifyRentLifecycle: IDL.Func([IDL.Text, IDL.Text], [Result_1], []),
+    sysNotifyWalletActivity: IDL.Func([IDL.Text], [Result_1], []),
+    sysRecordFeeEvent: IDL.Func(
+      [
+        IDL.Record({
+          paidThroughNs: IDL.Opt(IDL.Int),
+          cycles: IDL.Nat,
+          scheduleVersion: IDL.Opt(IDL.Text),
+        }),
+      ],
+      [Result_1],
+      [],
+    ),
+    sysSetBillerId: IDL.Func([IDL.Principal], [Result_1], []),
+    sysSetEngramNumber: IDL.Func([IDL.Nat], [Result_1], []),
+    sysSetMarketId: IDL.Func([IDL.Principal], [Result_1], []),
+    sysSetMetricsReaderId: IDL.Func([IDL.Principal], [Result_1], []),
+    sysSignEip712: IDL.Func(
+      [IDL.Vec(IDL.Nat8), IDL.Vec(IDL.Tuple(IDL.Text, Eip712Value))],
+      [Result_4],
+      [],
+    ),
+    sysSignX402Payment: IDL.Func(
+      [
+        IDL.Nat,
+        IDL.Text,
+        IDL.Text,
+        IDL.Nat,
+        IDL.Text,
+        IDL.Text,
+        IDL.Opt(IDL.Text),
+        IDL.Opt(IDL.Text),
+      ],
+      [Result_3],
+      [],
+    ),
+    testActionAlert: IDL.Func([], [Result_1], []),
+    testGuardianAlert: IDL.Func([], [Result_1], []),
+    transferOwnership: IDL.Func([IDL.Principal], [Result_2], []),
+    unfreezePayments: IDL.Func([], [Result_1], []),
+    worldIdTransform: IDL.Func(
+      [
+        IDL.Record({
+          context: IDL.Vec(IDL.Nat8),
+          response: HttpRequestResult,
+        }),
+      ],
+      [HttpRequestResult],
+      ['query'],
+    ),
+    writeMemory: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [Result], []),
+  });
+  return Engram;
+};
+export const init = ({ IDL }) => {
+  return [
+    IDL.Opt(
+      IDL.Record({
+        owner: IDL.Opt(IDL.Principal),
+        registry: IDL.Opt(IDL.Principal),
+      }),
+    ),
+  ];
+};