@engramx/client 0.15.0 → 0.16.0-rc.2

package/dist/generated/engram.idl.js

@@ -0,0 +1,1366 @@
+// GENERATED — DO NOT EDIT BY HAND. Vendored copy of engramx/src/generated/engram.idl.js, the
+// didc output that scripts/gen-did.sh regenerates from the engram canister's source.
+//
+// WHY A COPY LIVES INSIDE THE PACKAGE. @engramx/client publishes `dist/` and nothing else, and
+// its tsconfig pins `rootDir: "src"` — so the package can neither import nor emit a module that
+// sits above its own source root. An import of ../../../src/generated resolves in this checkout
+// and resolves to NOTHING in the installed tarball. Vendoring the didc output into the package is
+// what makes the generated factory reachable at build time AND at install time.
+//
+// This is a MACHINE copy, not a hand copy, and that distinction is the whole point: the hand IDL
+// it replaces could (and historically did) mistype a field or drop a variant tag, a class of
+// defect Candid surfaces only when the first value carrying that shape appears. The freshness gate
+// in test/idl-fidelity.test.ts fails if this file is not byte-derivable from the source above.
+//
+// INTERIM. ADR-0018 (ratified 2026-08-16) ships these interfaces as an npm-pinned artifact;
+// execution-plan W2 item 5 / W3 item 3 build it. When that artifact exists this file is deleted
+// and the package depends on it instead, and the freshness gate goes with it.
+// ---- GENERATED SOURCE BELOW: byte-identical to the .js apart from the `{ IDL: any }` annotation ----
+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),
+        })),
+    ];
+};
+//# sourceMappingURL=engram.idl.js.map