@ixo/editor 5.9.1 → 5.10.0

package/dist/{index-7l_Wftr_.d.ts → index-DKKQa1q-.d.ts}

@@ -1,10 +1,2436 @@
 import * as _blocknote_core from '@blocknote/core';
 import { BlockSchemaFromSpecs, InlineContentSchema, StyleSchema, BlockNoteEditor, PartialBlock } from '@blocknote/core';
 import * as React from 'react';
+import React__default from 'react';
 import { MatrixClient } from 'matrix-js-sdk';
 import { Map, Doc, Array as Array$1 } from 'yjs';
 import { Delegation } from '@ixo/ucan';
 
+type ProposalActionType = 'Spend' | 'UpdateMembers' | 'Stake' | 'Join' | 'AuthzExec' | 'AuthzGrant' | 'AuthzRevoke' | 'BurnNft' | 'Mint' | 'Execute' | 'Instantiate' | 'ManageSubDaos' | 'ManageCw721' | 'ManageCw20' | 'Migrate' | 'TransferNft' | 'UpdateAdmin' | 'UpdatePreProposeConfig' | 'UpdateVotingConfig' | 'GovernanceVote' | 'WithdrawTokenSwap' | 'UpdateInfo' | 'Custom' | 'ManageStorageItems' | 'ValidatorActions' | 'PerformTokenSwap' | 'DaoAdminExec' | 'StakeToGroup' | 'SendGroupToken' | 'AcceptToMarketplace' | 'CreateEntity';
+interface Member$1 {
+    addr: string;
+    weight: number;
+}
+interface BaseProposalAction {
+    type: ProposalActionType;
+}
+interface SpendData {
+    to: string;
+    denom: string;
+    amount: string;
+}
+interface ManageMembersData {
+    add: Member$1[];
+    remove: {
+        addr: string;
+    }[];
+}
+interface SpendAction extends BaseProposalAction {
+    type: 'Spend';
+    data: SpendData;
+}
+interface UpdateMembersAction extends BaseProposalAction {
+    type: 'UpdateMembers';
+    data: ManageMembersData;
+}
+declare const StakeType: {
+    readonly Delegate: "delegate";
+    readonly Undelegate: "undelegate";
+    readonly Redelegate: "redelegate";
+    readonly WithdrawDelegatorReward: "withdraw_delegator_reward";
+};
+type StakeType = (typeof StakeType)[keyof typeof StakeType];
+interface StakeData {
+    stakeType: StakeType;
+    validator: string;
+    toValidator: string;
+    amount: string;
+    denom: string;
+}
+interface JoinData {
+    id: string;
+    coreAddress: string;
+    address: string;
+}
+interface StakeAction extends BaseProposalAction {
+    type: 'Stake';
+    data: StakeData;
+}
+interface JoinAction extends BaseProposalAction {
+    type: 'Join';
+    data: JoinData;
+}
+interface Coin$1 {
+    denom: string;
+    amount: string;
+}
+interface Binary {
+    [k: string]: unknown;
+}
+interface Empty {
+    [k: string]: unknown;
+}
+interface GenericToken {
+    [k: string]: unknown;
+}
+interface SubDao {
+    addr: string;
+    charter?: string | null;
+    [k: string]: unknown;
+}
+interface Counterparty {
+    address: string;
+    [k: string]: unknown;
+}
+type DepositRefundPolicy = string;
+type VoteOption = number;
+type TProposalActionModel = any;
+interface MsgDelegate {
+    [k: string]: unknown;
+}
+interface MsgUndelegate {
+    [k: string]: unknown;
+}
+interface MsgBeginRedelegate {
+    [k: string]: unknown;
+}
+interface MsgWithdrawDelegatorReward {
+    [k: string]: unknown;
+}
+type BankMsg = {
+    send: {
+        amount: Coin$1[];
+        to_address: string;
+    };
+} | {
+    burn: {
+        amount: Coin$1[];
+    };
+};
+type StakingMsg = {
+    delegate: {
+        amount: Coin$1;
+        validator: string;
+    };
+} | {
+    undelegate: {
+        amount: Coin$1;
+        validator: string;
+    };
+} | {
+    redelegate: {
+        amount: Coin$1;
+        dst_validator: string;
+        src_validator: string;
+    };
+};
+type DistributionMsg = {
+    set_withdraw_address: {
+        address: string;
+    };
+} | {
+    withdraw_delegator_reward: {
+        validator: string;
+    };
+};
+interface IbcTimeout {
+    [k: string]: unknown;
+}
+type IbcMsg = {
+    transfer: {
+        amount: Coin$1;
+        channel_id: string;
+        timeout: IbcTimeout;
+        to_address: string;
+    };
+} | {
+    send_packet: {
+        channel_id: string;
+        data: Binary;
+        timeout: IbcTimeout;
+    };
+} | {
+    close_channel: {
+        channel_id: string;
+    };
+};
+type WasmMsg = {
+    execute: {
+        contract_addr: string;
+        funds: Coin$1[];
+        msg: Binary;
+    };
+} | {
+    instantiate: {
+        admin?: string | null;
+        code_id: number;
+        funds: Coin$1[];
+        label: string;
+        msg: Binary;
+    };
+} | {
+    migrate: {
+        contract_addr: string;
+        msg: Binary;
+        new_code_id: number;
+    };
+} | {
+    update_admin: {
+        admin: string;
+        contract_addr: string;
+    };
+} | {
+    clear_admin: {
+        contract_addr: string;
+    };
+};
+type GovMsg = {
+    vote: {
+        proposal_id: number;
+        vote: VoteOption;
+    };
+};
+type StargateMsg = {
+    stargate: {
+        type_url: string;
+        value: Binary;
+    };
+};
+type CosmosMsgFor_Empty = {
+    bank: BankMsg;
+} | {
+    custom: Empty;
+} | {
+    staking: StakingMsg;
+} | {
+    distribution: DistributionMsg;
+} | {
+    ibc: IbcMsg;
+} | {
+    wasm: WasmMsg;
+} | {
+    gov: GovMsg;
+} | StargateMsg;
+declare const AuthzExecActionTypes: {
+    readonly Delegate: "/cosmos.staking.v1beta1.MsgDelegate";
+    readonly Undelegate: "/cosmos.staking.v1beta1.MsgUndelegate";
+    readonly Redelegate: "/cosmos.staking.v1beta1.MsgBeginRedelegate";
+    readonly ClaimRewards: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward";
+    readonly Custom: "custom";
+};
+type AuthzExecActionType = (typeof AuthzExecActionTypes)[keyof typeof AuthzExecActionTypes];
+interface AuthzExecData {
+    authzExecActionType: AuthzExecActionType;
+    delegate: MsgDelegate;
+    undelegate: MsgUndelegate;
+    redelegate: MsgBeginRedelegate;
+    claimRewards: MsgWithdrawDelegatorReward;
+    custom: string;
+}
+interface AuthzData {
+    custom?: boolean;
+    typeUrl: string;
+    value: {
+        grantee: string;
+        msgTypeUrl: string;
+    };
+}
+interface BurnNftData {
+    collection: string;
+    tokenId: string;
+}
+interface ExecuteData {
+    address: string;
+    message: string;
+    funds: Coin$1[];
+}
+interface InstantiateData {
+    admin: string;
+    codeId: number;
+    label: string;
+    message: string;
+    funds: Coin$1[];
+}
+interface ManageSubDaosData {
+    toAdd: SubDao[];
+    toRemove: {
+        address: string;
+    }[];
+}
+interface ManageCw721Data {
+    adding: boolean;
+    address: string;
+}
+interface ManageCw20Data {
+    adding: boolean;
+    address: string;
+}
+interface MigrateData {
+    contract: string;
+    codeId: number;
+    msg: string;
+}
+interface MintData {
+    to: string;
+    amount: number;
+}
+interface TransferNftData {
+    collection: string;
+    tokenId: string;
+    recipient: string;
+    executeSmartContract: boolean;
+    smartContractMsg: string;
+}
+interface UpdateAdminData {
+    contract: string;
+    newAdmin: string;
+}
+interface UpdatePreProposeConfigData {
+    depositRequired: boolean;
+    depositInfo: {
+        amount: string;
+        type: 'native' | 'cw20' | 'voting_module_token';
+        denomOrAddress: string;
+        token?: GenericToken;
+        refundPolicy: DepositRefundPolicy;
+    };
+    anyoneCanPropose: boolean;
+}
+interface UpdateProposalConfigData {
+    onlyMembersExecute: boolean;
+    thresholdType: '%' | 'majority';
+    thresholdPercentage?: number;
+    quorumEnabled: boolean;
+    quorumType: '%' | 'majority';
+    quorumPercentage?: number;
+    proposalDuration: number;
+    proposalDurationUnits: 'weeks' | 'days' | 'hours' | 'minutes' | 'seconds';
+    allowRevoting: boolean;
+}
+interface GovernanceVoteData {
+    proposalId: string;
+    vote: VoteOption;
+}
+interface WithdrawTokenSwapData {
+    contractChosen: boolean;
+    tokenSwapContractAddress?: string;
+}
+interface UpdateInfoData {
+    automatically_add_cw20s: boolean;
+    automatically_add_cw721s: boolean;
+    dao_uri?: string | null;
+    description: string;
+    image_url?: string | null;
+    name: string;
+    [k: string]: unknown;
+}
+interface CustomData {
+    message: string;
+}
+interface ManageStorageItemsData {
+    setting: boolean;
+    key: string;
+    value: string;
+}
+declare enum ValidatorActionType {
+    CreateValidator = "/cosmos.staking.v1beta1.MsgCreateValidator",
+    EditValidator = "/cosmos.staking.v1beta1.MsgEditValidator",
+    UnjailValidator = "/cosmos.slashing.v1beta1.MsgUnjail",
+    WithdrawValidatorCommission = "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission"
+}
+interface ValidatorActionsData {
+    validatorActionType: ValidatorActionType;
+    createMsg: string;
+    editMsg: string;
+}
+interface PerformTokenSwapData {
+    contractChosen: boolean;
+    tokenSwapContractAddress?: string;
+    selfParty?: Omit<Counterparty, 'address'>;
+    counterparty?: Counterparty;
+}
+type DaoAdminExecData = {
+    coreAddress: string;
+    msgs: CosmosMsgFor_Empty[];
+    _actions?: TProposalActionModel[];
+};
+interface StakeToGroupData {
+    amount: string;
+    tokenContract: string;
+    stakingContract: string;
+}
+interface SendGroupTokenData {
+    amount: string;
+    contract: string;
+    toAddress: string;
+}
+interface AcceptToMarketplaceData {
+    did: string;
+    relayerNodeDid: string;
+    relayerNodeAddress: string;
+}
+interface AuthzExecAction extends BaseProposalAction {
+    type: 'AuthzExec';
+    data: AuthzExecData;
+}
+interface AuthzGrantAction extends BaseProposalAction {
+    type: 'AuthzGrant';
+    data: AuthzData;
+}
+interface AuthzRevokeAction extends BaseProposalAction {
+    type: 'AuthzRevoke';
+    data: AuthzData;
+}
+interface BurnNftAction extends BaseProposalAction {
+    type: 'BurnNft';
+    data: BurnNftData;
+}
+interface MintAction extends BaseProposalAction {
+    type: 'Mint';
+    data: MintData;
+}
+interface ExecuteAction extends BaseProposalAction {
+    type: 'Execute';
+    data: ExecuteData;
+}
+interface InstantiateAction extends BaseProposalAction {
+    type: 'Instantiate';
+    data: InstantiateData;
+}
+interface ManageSubDaosAction extends BaseProposalAction {
+    type: 'ManageSubDaos';
+    data: ManageSubDaosData;
+}
+interface ManageCw721Action extends BaseProposalAction {
+    type: 'ManageCw721';
+    data: ManageCw721Data;
+}
+interface ManageCw20Action extends BaseProposalAction {
+    type: 'ManageCw20';
+    data: ManageCw20Data;
+}
+interface MigrateAction extends BaseProposalAction {
+    type: 'Migrate';
+    data: MigrateData;
+}
+interface TransferNftAction extends BaseProposalAction {
+    type: 'TransferNft';
+    data: TransferNftData;
+}
+interface UpdateAdminAction extends BaseProposalAction {
+    type: 'UpdateAdmin';
+    data: UpdateAdminData;
+}
+interface UpdatePreProposeConfigAction extends BaseProposalAction {
+    type: 'UpdatePreProposeConfig';
+    data: UpdatePreProposeConfigData;
+}
+interface UpdateVotingConfigAction extends BaseProposalAction {
+    type: 'UpdateVotingConfig';
+    data: UpdateProposalConfigData;
+}
+interface GovernanceVoteAction extends BaseProposalAction {
+    type: 'GovernanceVote';
+    data: GovernanceVoteData;
+}
+interface WithdrawTokenSwapAction extends BaseProposalAction {
+    type: 'WithdrawTokenSwap';
+    data: WithdrawTokenSwapData;
+}
+interface UpdateInfoAction extends BaseProposalAction {
+    type: 'UpdateInfo';
+    data: UpdateInfoData;
+}
+interface CustomAction extends BaseProposalAction {
+    type: 'Custom';
+    data: CustomData;
+}
+interface ManageStorageItemsAction extends BaseProposalAction {
+    type: 'ManageStorageItems';
+    data: ManageStorageItemsData;
+}
+interface ValidatorActionsAction extends BaseProposalAction {
+    type: 'ValidatorActions';
+    data: ValidatorActionsData;
+}
+interface PerformTokenSwapAction extends BaseProposalAction {
+    type: 'PerformTokenSwap';
+    data: PerformTokenSwapData;
+}
+interface DaoAdminExecAction extends BaseProposalAction {
+    type: 'DaoAdminExec';
+    data: DaoAdminExecData;
+}
+interface StakeToGroupAction extends BaseProposalAction {
+    type: 'StakeToGroup';
+    data: StakeToGroupData;
+}
+interface SendGroupTokenAction extends BaseProposalAction {
+    type: 'SendGroupToken';
+    data: SendGroupTokenData;
+}
+interface AcceptToMarketplaceAction extends BaseProposalAction {
+    type: 'AcceptToMarketplace';
+    data: AcceptToMarketplaceData;
+}
+interface CreateEntityAction extends BaseProposalAction {
+    type: 'CreateEntity';
+    data: any;
+}
+type ProposalAction = SpendAction | UpdateMembersAction | StakeAction | JoinAction | AuthzExecAction | AuthzGrantAction | AuthzRevokeAction | BurnNftAction | MintAction | ExecuteAction | InstantiateAction | ManageSubDaosAction | ManageCw721Action | ManageCw20Action | MigrateAction | TransferNftAction | UpdateAdminAction | UpdatePreProposeConfigAction | UpdateVotingConfigAction | GovernanceVoteAction | WithdrawTokenSwapAction | UpdateInfoAction | CustomAction | ManageStorageItemsAction | ValidatorActionsAction | PerformTokenSwapAction | DaoAdminExecAction | StakeToGroupAction | SendGroupTokenAction | AcceptToMarketplaceAction | CreateEntityAction;
+interface SharedProposalData {
+    [proposalId: string]: {
+        proposal: any;
+        lastFetched: number;
+        loading: boolean;
+        error?: Error;
+    };
+}
+
+type Addr = string;
+type Uint128 = string;
+type Timestamp = string;
+interface Coin {
+    denom: string;
+    amount: string;
+}
+/**
+ * Cosmos SDK broadcast result. Returned by handlers that submit on-chain
+ * transactions (e.g. `evaluateClaim`). `code === 0` means success — non-zero
+ * codes are failures, but in practice handlers throw before returning so the
+ * editor only sees successful broadcasts here.
+ */
+interface BroadcastTxResult {
+    code: number;
+    transactionHash: string;
+    rawLog?: string;
+    height?: number;
+    txIndex?: number;
+    gasWanted?: bigint;
+    gasUsed?: bigint;
+}
+type Expiration = {
+    at_height: number;
+} | {
+    at_time: Timestamp;
+} | {
+    never: {};
+};
+type Status = 'open' | 'rejected' | 'passed' | 'executed' | 'closed' | 'execution_failed' | 'veto_timelock';
+interface Threshold {
+    absolute_count?: {
+        weight: Uint128;
+    };
+    absolute_percentage?: {
+        percentage: string;
+    };
+    threshold_quorum?: {
+        threshold: string;
+        quorum: string;
+    };
+}
+interface Votes {
+    yes: Uint128;
+    no: Uint128;
+    abstain: Uint128;
+}
+interface CosmosMsgForEmpty {
+    [key: string]: any;
+}
+interface SingleChoiceProposal {
+    allow_revoting: boolean;
+    description: string;
+    expiration: Expiration;
+    min_voting_period?: Expiration | null;
+    msgs: CosmosMsgForEmpty[];
+    proposer: Addr;
+    start_height: number;
+    status: Status;
+    threshold: Threshold;
+    title: string;
+    total_power: Uint128;
+    votes: Votes;
+}
+interface ProposalResponse {
+    id: number;
+    proposal: SingleChoiceProposal;
+}
+type Vote = 'yes' | 'no' | 'abstain' | 'no_with_veto';
+interface VoteInfo {
+    power: Uint128;
+    rationale?: string | null;
+    vote: Vote;
+    voter: Addr;
+}
+interface VoteResponse {
+    vote?: VoteInfo | null;
+}
+interface User {
+    address: string;
+}
+type AwarenessDocActor = {
+    name: string;
+    did: string;
+    src: string | null;
+};
+type IUserMatrixProfile = {
+    walletAddress: string;
+    displayname: string;
+    avatarUrl: string | null;
+    did: string;
+    verified?: boolean;
+};
+interface LinkedResource {
+    id: string;
+    type: string;
+    proof: string;
+    right: string;
+    encrypted: string;
+    mediaType: string;
+    description: string;
+    serviceEndpoint: string;
+}
+interface Service {
+    id: string;
+    type: string;
+    serviceEndpoint: string;
+}
+interface GQLLinkedResource {
+    id: string;
+    type: string;
+    description: string;
+    mediaType: string;
+    serviceEndpoint: string;
+    proof: string;
+    encrypted: string;
+    right: string;
+}
+interface EntityNode {
+    id: string;
+    type: string;
+    startDate?: string;
+    endDate?: string;
+    status: number;
+    relayerNode: string;
+    credentials?: string[];
+    entityVerified: boolean;
+    metadata: any;
+    accounts: any;
+    externalId?: string;
+    owner?: string;
+    context: any;
+    controller: string[];
+    verificationMethod: any;
+    service: Service[];
+    authentication: string[];
+    assertionMethod: string[];
+    keyAgreement: string[];
+    capabilityInvocation: string[];
+    capabilityDelegation: string[];
+    linkedResource: LinkedResource[];
+    linkedClaim: any;
+    accordedRight: any;
+    linkedEntity: any;
+    alsoKnownAs: string;
+    settings: any;
+    profile?: {
+        name?: string;
+        [key: string]: any;
+    };
+    iidById: {
+        id: string;
+        linkedResource: GQLLinkedResource[];
+    };
+}
+interface EntityResponse {
+    id: string;
+    context: string;
+    relayerNode: string;
+    controller: string;
+    type: string;
+    startDate: string;
+    endDate: string;
+    metadata: string;
+    linkedResource: LinkedResource[];
+    settings: Record<string, LinkedResource>;
+    service: Service[];
+    externalId: string;
+}
+interface Asset {
+    did: string;
+    alsoKnownAs: string;
+    name: string;
+    icon: string;
+    issuer: string;
+    owned: boolean;
+    price: number;
+    available: boolean;
+    currency: string;
+    description?: string;
+}
+interface POD {
+    did: string;
+    name: string;
+    icon: string;
+    members: number;
+    isMember: boolean;
+    totalProposals: number;
+    startDate: string;
+    endDate: string;
+    description?: string;
+}
+interface Request {
+    did: string;
+    name: string;
+    icon: string;
+    budget: number;
+    isMember: boolean;
+    currency: string;
+    brand: string;
+    totalApplications: number;
+    description?: string;
+}
+interface Project {
+    did: string;
+    name: string;
+    icon: string;
+    description?: string;
+}
+interface Dao {
+    did: string;
+    name: string;
+    icon: string;
+    description?: string;
+    type?: 'dao' | 'pod' | 'group';
+    isOwner?: boolean;
+    isController?: boolean;
+    isMember?: boolean;
+}
+interface Balance {
+    denom: string;
+    tokenName: string;
+    chainCount: number;
+    tokenImage: string;
+    amount: number;
+    usdAmount: number;
+    isCoin: boolean;
+    isShare: boolean;
+    isCredit: boolean;
+}
+interface Oracle {
+    did: string;
+    name: string;
+    icon: string;
+    isActive: boolean;
+    isInvited: boolean;
+    minPoints: number;
+    maxPoints: number;
+    currency: string;
+    brand: string;
+    flowsAmount: number;
+    description?: string;
+}
+interface Proposal {
+    did: string;
+    name: string;
+    icon: string;
+    description: string;
+    isVotedOn: boolean;
+    vote: string | null;
+    status: string;
+}
+interface Member {
+    did: string;
+    username: string;
+    address: string;
+    icon: string;
+    percentage: string;
+    role: string;
+    description?: string;
+}
+interface Validator {
+    did: string;
+    name: string;
+    description: string;
+    icon: string;
+    amount: number;
+    currency: string;
+    commission: number;
+    isStaked: boolean;
+    isBonding: boolean;
+    isActive: boolean;
+}
+interface Investment {
+    did: string;
+    name: string;
+    icon: string;
+    brand: string;
+    isSubscribed: boolean;
+    isOpen: boolean;
+    currency: string;
+    currentAmount: number;
+    maxAmount: number;
+    status: string;
+    price: number;
+    description?: string;
+}
+interface Collection {
+    did: string;
+    name: string;
+    brand: string;
+    icon: string;
+    price: number;
+    currency: string;
+    totalAssets: number;
+    description?: string;
+}
+interface TransactionByHash {
+    code: number;
+    fee: {
+        payer: string;
+        amount: Array<{
+            denom: string;
+            amount: string;
+        }>;
+        granter: string;
+        gasLimit: {
+            low: number;
+            high: number;
+            unsigned: boolean;
+        };
+    };
+    hash: string;
+    height: number;
+    memo: string;
+    time: string;
+}
+interface Transaction {
+    id: number;
+    transactionHash: string;
+    typeUrl: string;
+    memo: string;
+    time: string;
+    from: string;
+    to: string | null;
+    denoms: string[];
+    tokenNames: string[];
+    value: Record<string, any>;
+    transactionByTransactionHash?: TransactionByHash;
+    description?: string;
+}
+interface DeedSubscription {
+    did: string;
+    subscriberAddress: string;
+    subscriberDid?: string;
+    subscriberName?: string;
+    subscriberImage?: string;
+    subscriptionDate: string;
+    status: 'active' | 'inactive' | 'pending';
+    metadata?: Record<string, any>;
+    actionSections?: SelectionActionSection[];
+}
+type IAssetsListItem = {
+    symbol: string;
+    description: string;
+    display: string;
+    entityId: string;
+    assetType: string;
+    coinMinimalDenom?: string;
+    base: string;
+    denomUnits: {
+        denom: string;
+        exponent: number;
+        aliases: string[];
+    }[];
+    logoURIs: {
+        png: string;
+        svg: string;
+        zlottie: string;
+    };
+    isStakeCurrency: string;
+    isFeeCurrency: string;
+    isBondToken: string;
+    coingeckoId?: string;
+    contractAddress?: string;
+};
+interface Bid {
+    id: string;
+    did: string;
+    collection: string;
+    type: 'bid';
+    address: string;
+    data: string;
+    role: string;
+    created: string;
+}
+interface SubmitBidParams {
+    collectionId: string;
+    role: EAAgentRoles;
+    surveyAnswers: any;
+}
+interface QueryBidsParams {
+    collectionId: string;
+    pagination?: {
+        nextPageToken?: string;
+    };
+}
+interface QueryBidsByDidParams {
+    collectionId: string;
+    did: string;
+}
+interface ApproveBidParams {
+    bidId: string;
+    collectionId: string;
+    did: string;
+}
+interface RejectBidParams {
+    bidId: string;
+    collectionId: string;
+    did: string;
+    reason: string;
+}
+interface BidResponse {
+    success: boolean;
+    bidId: string;
+}
+interface QueryBidsResponse {
+    data: Bid[];
+    nextPageToken?: string;
+}
+declare enum EAAgentRoles {
+    owners = "PO",
+    evaluators = "EA",
+    serviceProviders = "SA",
+    investors = "IA"
+}
+declare enum AgentRole {
+    Owner = "PO",// Collection Controller
+    Evaluator = "EA",// Evaluator
+    ServiceProvider = "SA",// Contributor
+    Investor = "IA"
+}
+type CheckUserRoleParams = {
+    /** Address to check role for */
+    userAddress: string;
+    /** Admin account address of the entity */
+    adminAddress: string;
+    /** Deed DID */
+    deedDid: string;
+    /** Claim collection IDs to check roles for */
+    collectionIds: string[];
+};
+type ClaimCollectionRole = {
+    collectionId: string;
+    role: AgentRole;
+};
+type ClaimCollection = {
+    id: string;
+    name: string;
+    description: string;
+    entity: string;
+    protocol: EntityNode | null;
+    admin: string;
+};
+type ClaimCollectionResponse = {
+    adminAddress: string;
+    collections: ClaimCollection[];
+};
+type Claim = {
+    claimId: string;
+    collectionId: string;
+    agentDid: string;
+    agentAddress: string;
+    submissionDate: string;
+    paymentsStatus: {
+        approval: string;
+        rejection: string;
+        evaluation: string;
+        submission: string;
+    };
+    schemaType: string | null;
+    approved?: boolean;
+    pending?: boolean;
+    rejected?: boolean;
+    disputed?: boolean;
+};
+interface GetClaimsPerCollectionIdParams {
+    collectionId: string;
+}
+interface GetClaimsPerUserAddressParams {
+    collectionId: string;
+    userAddress: string;
+}
+interface FAQItem {
+    question: string;
+    answer: string;
+}
+interface ContactInfo {
+    email: string;
+    location: string;
+    socialLinks: string[];
+    website: string;
+}
+interface Relationships {
+    funders?: string[];
+    memberOf?: string[];
+    partners?: string[];
+}
+interface LogoUrl {
+    alt: string;
+    url: string;
+}
+interface AdditionalProperties {
+    content_hashes?: Record<string, string>;
+    content_summaries?: Record<string, string>;
+    fetch_errors?: Array<{
+        error: string;
+        url: string;
+    }>;
+    last_fetch_date?: string;
+}
+interface Coordinates {
+    type: string;
+    coordinates: [number, number];
+}
+interface DomainCard {
+    additional_properties?: AdditionalProperties;
+    address?: string;
+    alternate_names?: string[];
+    area_served?: string;
+    categories?: string[];
+    contact?: ContactInfo;
+    coordinates?: Coordinates;
+    credential_type?: string[];
+    description?: string;
+    entity_type?: string[];
+    faq?: FAQItem[];
+    id: string;
+    image_urls?: Array<Record<string, any>>;
+    indexed_at?: string;
+    issuer?: string;
+    keywords?: string[];
+    knows_about?: string[];
+    location?: string;
+    logo_url?: LogoUrl;
+    name: string;
+    overview?: string;
+    relationships?: Relationships;
+    same_as?: string[];
+    schema_id?: string;
+    summary?: string;
+    updated_at?: string;
+    url?: string;
+    valid_from?: string;
+}
+interface AssetDetails extends Asset {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface CollectionDetails extends Collection {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface TransactionDetails extends Transaction {
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface InvestmentDetails extends Investment {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface OracleDetails extends Oracle {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface PODDetails extends POD {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface ProposalDetails extends Proposal {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface RequestDetails extends Request {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface MemberDetails extends Member {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface ValidatorDetails extends Validator {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface LinkedResourceDetails extends LinkedResource {
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface ProjectDetails extends Project {
+    type: string;
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface DaoDetails extends Dao {
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface BalanceDetails extends Balance {
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface DeedSubscriptionDetails extends DeedSubscription {
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface ClaimDetails extends Claim {
+    image: string;
+    actionSections: SelectionActionSection[];
+}
+interface DAOGroup {
+    id: string;
+    name: string;
+    coreAddress: string;
+}
+interface BlockRequirements {
+    proposal?: {
+        coreAddress: string;
+    };
+}
+interface UnlMapConfig {
+    apiKey: string;
+    vpmId: string;
+}
+/**
+ * UDID outcome values matching EvaluationStatus enum
+ * PENDING = 0, APPROVED = 1, REJECTED = 2, DISPUTED = 3, INVALIDATED = 4, UNRECOGNIZED = -1
+ */
+type UdidOutcome = 0 | 1 | 2 | 3 | 4 | -1;
+/**
+ * Granular step result item for UDID
+ */
+interface UdidResultItem {
+    /** Unique identifier for this result item */
+    id: string;
+    /** Type of check/step */
+    kind: 'compute' | 'fetch' | 'check' | 'validate';
+    /** Whether this step passed */
+    success: boolean;
+    /** Score or value (optional) */
+    score?: number;
+    /** Output data from this step */
+    outputs?: Record<string, any>;
+    /** Human-readable message */
+    message?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Signed UDID structure
+ */
+interface SignedUdid {
+    /** Unique identifier for this UDID */
+    id: string;
+    /** The unsigned UDID payload */
+    payload: {
+        /** Subject of the evaluation (claim CID) */
+        sub: string;
+        /** Issuer DID (evaluator) */
+        iss: string;
+        /** Audience/context (deed DID) */
+        aud: string;
+        /** Issued at timestamp */
+        iat: number;
+        /** Expiration timestamp (optional) */
+        exp?: number;
+        /** Action/capability context */
+        act: {
+            capabilityCid: string;
+            capabilitySchema: string;
+            rubricAuthority: string;
+            rubricId: string;
+            environment: string;
+            evaluatorVersion?: string;
+        };
+        /** Result data */
+        res: {
+            outcome: number;
+            tag: string;
+            patch?: Record<string, any>;
+            traceCid?: string;
+            traceHash?: string;
+            items?: UdidResultItem[];
+            resultSchema?: string;
+        };
+        /** Metadata */
+        meta: {
+            collectionId: string;
+            timestamp: string;
+        };
+    };
+    /** Signature of the payload */
+    signature: string;
+    /** Verification method used for signing */
+    verificationMethod: string;
+}
+/**
+ * Parameters for creating a UDID
+ */
+interface CreateUdidParams {
+    /** CID of the claim being evaluated */
+    claimCid: string;
+    /** DID of the Deed/Context where this result applies */
+    deedDid: string;
+    /** Collection ID for the claim */
+    collectionId: string;
+    /** CID of the UCAN/capability that authorized this evaluation */
+    capabilityCid: string;
+    /** Schema of the capability (default: "ixo-protocol-v1") */
+    capabilitySchema?: string;
+    /** DID of the rubric authority (usually the Deed DID) */
+    rubricAuthority: string;
+    /** Version/ID of the rubric used */
+    rubricId: string;
+    /** Environment (default: "production") */
+    environment?: 'production' | 'simulation' | 'testnet';
+    /** Version of the evaluator (optional) */
+    evaluatorVersion?: string;
+    /** Outcome of the evaluation matching EvaluationStatus enum (0=PENDING, 1=APPROVED, 2=REJECTED, 3=DISPUTED, 4=INVALIDATED, -1=UNRECOGNIZED) */
+    outcome: UdidOutcome | number;
+    /** Human-readable tag for the outcome */
+    tag: string;
+    /** State patch to apply to Digital Twin (optional) */
+    patch?: Record<string, any>;
+    /** CID of the trace/reasoning logs (optional) */
+    traceCid?: string;
+    /** Hash of the trace for integrity (optional) */
+    traceHash?: string;
+    /** Granular step results (optional) */
+    items?: UdidResultItem[];
+    /** Schema for result validation (optional) */
+    resultSchema?: string;
+    /** Type of issuer: entity or user */
+    issuerType: 'entity' | 'user';
+    /** Entity room ID (required if issuerType is "entity") */
+    entityRoomId?: string;
+    /** PIN for decrypting signing key */
+    pin: string;
+    /** Expiration time in seconds from now (optional) */
+    expiresInSeconds?: number;
+}
+/**
+ * Response from creating a UDID
+ */
+interface CreateUdidResponse {
+    /** Whether the UDID was created successfully */
+    success: boolean;
+    /** The signed UDID */
+    udid: SignedUdid;
+    /** CID of the stored UDID in public storage (IPFS/Matrix) */
+    cid: string;
+    /** URL to fetch the UDID from public storage */
+    url: string;
+    /** Transaction hash if submitted on-chain */
+    transactionHash?: string;
+}
+interface VoteParams {
+    proposalId: number;
+    rationale?: string;
+    vote: Vote;
+    proposalContractAddress: string;
+}
+interface CreateProposalParams {
+    preProposalContractAddress: string;
+    title: string;
+    description: string;
+    actions?: ProposalAction[];
+    coreAddress?: string;
+    groupContractAddress?: string;
+}
+interface EmailNotificationParams {
+    channel: 'email';
+    to: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject: string;
+    body: string;
+    bodyType?: 'text' | 'html';
+    from?: string;
+    replyTo?: string;
+}
+interface SmsNotificationParams {
+    channel: 'sms';
+    to: string[];
+    body: string;
+}
+interface WhatsAppNotificationParams {
+    channel: 'whatsapp';
+    to: string[];
+    body: string;
+    templateId?: string;
+    templateVariables?: Record<string, string>;
+}
+type NotificationParams = EmailNotificationParams | SmsNotificationParams | WhatsAppNotificationParams;
+interface NotificationResponse {
+    messageId: string;
+    status: 'accepted' | 'rejected';
+    timestamp: string;
+}
+interface WorkspacePage {
+    id: string;
+    type: string;
+    description: string;
+    serviceEndpoint: string;
+    mediaType: string;
+}
+/**
+ * Toolkit keys recognised by the integrations layer. Kept as a string literal
+ * union so typos surface at compile time; extend as we add more toolkits.
+ */
+type IntegrationToolkit = 'googlecalendar' | 'xero';
+/**
+ * Normalised connection status returned by the host app. Mirrors Composio's
+ * underlying states but the editor never sees or names Composio directly.
+ */
+type IntegrationConnectionStatus = 'INITIALIZING' | 'ACTIVE' | 'FAILED' | 'EXPIRED';
+/**
+ * Structured error code for action-level UI decisions. Keep this small and
+ * stable — actions branch on it (see gotchas §7).
+ */
+type IntegrationErrorCode = 'OK' | 'VALIDATION' | 'AUTH_EXPIRED' | 'UPSTREAM_4XX' | 'UPSTREAM_5XX' | 'RATE_LIMIT' | 'UNKNOWN';
+interface IntegrationConnectionSummary {
+    connectedAccountId: string;
+    status: IntegrationConnectionStatus;
+    /** Human-readable label fetched server-side (e.g. Google email, Xero org name). */
+    label?: string;
+    createdAt: string;
+}
+interface IntegrationExecuteResult {
+    successful: boolean;
+    data?: Record<string, unknown>;
+    error?: string;
+    code?: IntegrationErrorCode;
+}
+interface IntegrationsHandlers {
+    /** Kick off OAuth — host returns the redirect URL to open in a popup and a pending ca_* id. */
+    startConnection: (args: {
+        toolkit: IntegrationToolkit;
+    }) => Promise<{
+        redirectUrl: string;
+        connectedAccountId: string;
+    }>;
+    /** Poll the status of a single connection (typically during the OAuth popup dance). */
+    getConnectionStatus: (args: {
+        connectedAccountId: string;
+    }) => Promise<{
+        status: IntegrationConnectionStatus;
+        error?: string;
+    }>;
+    /** List all connections the current entity has for a given toolkit. */
+    listConnections: (args: {
+        toolkit: IntegrationToolkit;
+    }) => Promise<IntegrationConnectionSummary[]>;
+    /** Revoke a connection (server-side). Idempotent. */
+    disconnect: (args: {
+        connectedAccountId: string;
+    }) => Promise<void>;
+    /** Single entry point for every tool execution. `toolSlug` is the underlying platform's slug. */
+    executeTool: (args: {
+        toolSlug: string;
+        connectedAccountId: string;
+        arguments: Record<string, unknown>;
+    }) => Promise<IntegrationExecuteResult>;
+    /** Optional read-tool call used by diff resolvers to populate "before" state on update actions. */
+    fetchCurrentState?: (args: {
+        toolSlug: string;
+        connectedAccountId: string;
+        arguments: Record<string, unknown>;
+    }) => Promise<Record<string, unknown>>;
+}
+interface BlocknoteHandlers {
+    getVote: (proposalContractAddress: string, proposalId: string, userAddress: string) => Promise<VoteResponse>;
+    getProposal: (proposalContractAddress: string, proposalId: string) => Promise<ProposalResponse>;
+    getCurrentUser: () => User;
+    getRoomMembers: (roomId: string, mx: MatrixClient) => Promise<AwarenessDocActor[]>;
+    getMatrixInfoPerDid: (did: string) => Promise<IUserMatrixProfile>;
+    getDaoGroupsIds: () => Promise<string[] | undefined>;
+    getDAOGroups: () => Promise<DAOGroup[]>;
+    getRelayerDid: () => string | undefined;
+    getEntityDid: () => string | undefined;
+    getAdminAccountAddress: (deedDid: string) => Promise<string>;
+    getOnlyClaimCollections: (deedDid: string) => Promise<ClaimCollection[]>;
+    vote: ({ proposalId, rationale, vote, proposalContractAddress }: VoteParams) => Promise<void>;
+    createProposal: (params: CreateProposalParams) => Promise<string>;
+    getEntity: (did: string) => Promise<EntityResponse>;
+    getDomainCard: () => Promise<DomainCard>;
+    askCompanion: (prompt: string) => Promise<void>;
+    getCryptoAssets: () => Promise<IAssetsListItem[]>;
+    getAssets: (collectionDid: string, page: number, ownerAddress?: string) => Promise<{
+        data: Asset[];
+        totalCount: number;
+    }>;
+    getDeedSubscriptions: (relayerDid: string, page: number) => Promise<{
+        data: DeedSubscription[];
+        totalCount: number;
+    }>;
+    getCollections: (relayerDid: string, page: number) => Promise<{
+        data: Collection[];
+        totalCount: number;
+    }>;
+    getTransactions: (address: string, page: number) => Promise<{
+        data: Transaction[];
+        totalCount: number;
+    }>;
+    getInvestments: (relayerDid: string, page: number) => Promise<{
+        data: Investment[];
+        totalCount: number;
+    }>;
+    getOracles: (relayerDid: string, page: number) => Promise<{
+        data: Oracle[];
+        totalCount: number;
+    }>;
+    getPODs: (relayerDid: string, page: number, role?: string) => Promise<{
+        data: POD[];
+        totalCount: number;
+    }>;
+    getProposals: (relayerDid: string, page: number) => Promise<{
+        data: Proposal[];
+        totalCount: number;
+    }>;
+    getRequests: (relayerDid: string, page: number) => Promise<{
+        data: Request[];
+        totalCount: number;
+    }>;
+    getDaos: (relayerDid: string, page: number, role?: string) => Promise<{
+        data: Dao[];
+        totalCount: number;
+    }>;
+    getDaoGroups?: (relayerDid: string, page: number, role?: string) => Promise<{
+        data: Dao[];
+        totalCount: number;
+    }>;
+    getProjects: (relayerDid: string, page: number) => Promise<{
+        data: Project[];
+        totalCount: number;
+    }>;
+    getMembers: (address: string, groupCoreAddress: string, withBalance: boolean, page: number) => Promise<{
+        data: Member[];
+        totalCount: number;
+    }>;
+    getDaoMembers: (address: string, groupIds: string[], withBalance: boolean, page: number) => Promise<{
+        data: Member[];
+        totalCount: number;
+    }>;
+    getValidators: (relayerDid: string, page: number) => Promise<{
+        data: Validator[];
+        totalCount: number;
+    }>;
+    executeProposal: (params: {
+        proposalId: number;
+        proposalContractAddress: string;
+    }) => Promise<void>;
+    getProposalContractAddress: (params: {
+        coreAddress: string;
+    }) => Promise<{
+        proposalContractAddress: string;
+    }>;
+    getPreProposalContractAddress: (params: {
+        coreAddress: string;
+    }) => Promise<{
+        preProposalContractAddress: string;
+    }>;
+    getGroupContractAddress: (params: {
+        coreAddress: string;
+    }) => Promise<{
+        groupContractAddress: string;
+    }>;
+    getBalances: (address: string) => Promise<{
+        data: Balance[];
+    }>;
+    sendNotification: (params: NotificationParams) => Promise<NotificationResponse>;
+    getAssetDetails?: (id: string) => Promise<AssetDetails>;
+    getCollectionDetails?: (id: string) => Promise<CollectionDetails>;
+    getTransactionDetails?: (id: string) => Promise<TransactionDetails>;
+    getInvestmentDetails?: (id: string) => Promise<InvestmentDetails>;
+    getOracleDetails?: (id: string) => Promise<OracleDetails>;
+    getPODDetails?: (id: string) => Promise<PODDetails>;
+    getProposalDetails?: (id: string) => Promise<ProposalDetails>;
+    getRequestDetails?: (id: string) => Promise<RequestDetails>;
+    getMemberDetails?: (id: string) => Promise<MemberDetails>;
+    getValidatorDetails?: (id: string) => Promise<ValidatorDetails>;
+    getLinkedResourceDetails?: (id: string) => Promise<LinkedResourceDetails>;
+    getDaoMemberDetails?: (id: string) => Promise<MemberDetails>;
+    getProjectDetails?: (id: string) => Promise<ProjectDetails>;
+    getDaoDetails?: (id: string) => Promise<DaoDetails>;
+    getBalanceDetails?: (id: string) => Promise<BalanceDetails>;
+    getDeedSubscriptionDetails?: (id: string) => Promise<DeedSubscriptionDetails>;
+    getClaimDetails?: (id: string) => Promise<ClaimDetails>;
+    getDeedSurveyTemplate: (deedDid: string, claimCollectionId?: string) => Promise<{
+        surveyTemplate: any;
+        claimCollectionId: string;
+    } | null>;
+    submitClaim: (params: {
+        surveyData: any;
+        deedDid: string;
+        collectionId: string;
+        adminAddress: string;
+        pin: string;
+    }) => Promise<{
+        transactionHash: string;
+        claimId: string;
+    }>;
+    requestPin: (config?: {
+        title?: string;
+        description?: string;
+        submitText?: string;
+    }) => Promise<string>;
+    getClaimCollections: (deedDid: string) => Promise<ClaimCollectionResponse>;
+    getClaimsPerCollectionId: (params: GetClaimsPerCollectionIdParams) => Promise<Claim[]>;
+    getClaimsPerUserAddress: (params: GetClaimsPerUserAddressParams) => Promise<Claim[]>;
+    getClaimData: (collectionId: string, claimId: string) => Promise<any>;
+    getClaimDisputeDetails?: (claimId: string) => Promise<{
+        reason?: string;
+        disputeType?: number;
+        evaluatorDid?: string;
+        disputedAt?: string;
+        uri?: string;
+        proof?: string;
+    } | null>;
+    /** Fetch the outcome data captured at evaluation time (patch from the
+     * UDID referenced by `verificationProof`) along with the on-chain
+     * evaluation record. Used to repopulate the outcome template and surface
+     * the actual transferred amount for already-evaluated claims. */
+    getClaimEvaluationDetails?: (claimId: string) => Promise<{
+        patch?: Record<string, any>;
+        evaluatorDid?: string;
+        evaluatedAt?: string;
+        /** Authoritative on-chain transfer amount(s) from the MsgEvaluateClaim tx. */
+        amount?: Coin[];
+        /** Optional reason recorded with the evaluation (typically for reject). */
+        reason?: string;
+    } | null>;
+    fetchClaimMedia?: (url: string) => Promise<Blob>;
+    evaluateClaim: (granteeAddress: string, did: string, payload: {
+        claimId: string;
+        collectionId: string;
+        adminAddress: string;
+        status?: number;
+        verificationProof: string;
+        amount?: Coin;
+    }) => Promise<BroadcastTxResult>;
+    disputeClaim?: (granteeAddress: string, did: string, payload: {
+        subjectId: string;
+        disputeType: number;
+        reason: string;
+    }) => Promise<any>;
+    submitBid: (params: SubmitBidParams) => Promise<BidResponse>;
+    queryBids: (params: QueryBidsParams) => Promise<QueryBidsResponse>;
+    queryBidsByDid: (params: QueryBidsByDidParams) => Promise<{
+        data: Bid[];
+    }>;
+    approveBid: (params: ApproveBidParams) => Promise<BidResponse>;
+    rejectBid: (params: RejectBidParams) => Promise<BidResponse>;
+    getUserRoles: (params: CheckUserRoleParams) => Promise<ClaimCollectionRole[]>;
+    getBidContributorSurveyTemplate: (deedId: string, claimCollectionId?: string) => Promise<{
+        surveyTemplate: any;
+    } | null>;
+    getBidEvaluatorSurveyTemplate: (deedId: string, claimCollectionId?: string) => Promise<{
+        surveyTemplate: any;
+    } | null>;
+    approveServiceAgentApplication: (params: {
+        adminAddress: string;
+        collectionId: string;
+        agentQuota: number;
+        deedDid: string;
+        currentUserAddress: string;
+    }) => Promise<void>;
+    approveEvaluatorApplication: (params: {
+        adminAddress: string;
+        collectionId: string;
+        deedDid: string;
+        evaluatorAddress: string;
+        agentQuota?: number;
+        claimIds?: string[];
+        maxAmounts?: Coin[];
+    }) => Promise<void>;
+    publicFileUpload: (file: File) => Promise<{
+        encrypted: string;
+        cid: string;
+        proof: string;
+        serviceEndpoint: string;
+        url: string;
+        mxc: string;
+    }>;
+    /**
+     * Check if entity has signing key set up
+     */
+    checkEntitySigningSetup?: (entityDid: string) => Promise<{
+        hasSigningKey: boolean;
+        keyId?: string;
+    }>;
+    /**
+     * Set up entity signing (generates mnemonic, adds verification method)
+     * Requires wallet signature
+     */
+    setupEntitySigning?: (params: {
+        entityDid: string;
+        entityRoomId: string;
+        pin: string;
+    }) => Promise<{
+        transactionHash: string;
+        keyId: string;
+    }>;
+    /**
+     * Check if current user has signing key set up
+     */
+    checkUserSigningSetup?: () => Promise<{
+        hasSigningKey: boolean;
+        keyId?: string;
+    }>;
+    /**
+     * Sign a capability delegation
+     * @deprecated Use createDelegation instead for @ixo/ucan CAR format
+     */
+    signCapability?: (params: {
+        /** DID of issuer (entity or user) */
+        issuerDid: string;
+        /** Whether signing as entity or user */
+        issuerType: 'entity' | 'user';
+        /** Entity room ID (required if issuerType is 'entity') */
+        entityRoomId?: string;
+        /** DID of recipient */
+        audience: string;
+        /** Capabilities to grant */
+        capabilities: Array<{
+            can: string;
+            with: string;
+            nb?: Record<string, any>;
+        }>;
+        /** IDs of parent capabilities (proofs) */
+        proofs?: string[];
+        /** Expiration timestamp */
+        expiration?: number;
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+    }) => Promise<{
+        id: string;
+        raw: string;
+        signature: string;
+    }>;
+    /**
+     * Verify a capability signature against issuer's DID document
+     * @deprecated Use validateInvocation instead
+     */
+    verifyCapabilitySignature?: (params: {
+        /** Raw capability JSON */
+        capabilityRaw: string;
+        /** Expected issuer DID */
+        issuerDid: string;
+    }) => Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
+    /**
+     * Create a delegation using @ixo/ucan (CAR format)
+     */
+    createDelegation?: (params: {
+        /** DID of issuer */
+        issuerDid: string;
+        /** Whether signing as entity or user */
+        issuerType: 'entity' | 'user';
+        /** Entity room ID (required if issuerType is 'entity') */
+        entityRoomId?: string;
+        /** DID of recipient */
+        audience: string;
+        /** Capabilities to grant */
+        capabilities: Array<{
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        }>;
+        /** CIDs of proof delegations */
+        proofs?: string[];
+        /** Expiration timestamp (milliseconds) */
+        expiration?: number;
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+    }) => Promise<{
+        /** Content ID of the delegation */
+        cid: string;
+        /** Base64-encoded CAR bytes */
+        delegation: string;
+    }>;
+    /**
+     * Create an invocation using @ixo/ucan (CAR format)
+     */
+    createInvocation?: (params: {
+        /** DID of invoker */
+        invokerDid: string;
+        /** Whether signing as entity or user */
+        invokerType: 'entity' | 'user';
+        /** Entity room ID (required if invokerType is 'entity') */
+        entityRoomId?: string;
+        /** Capability to invoke */
+        capability: {
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        };
+        /** CIDs of proof delegations */
+        proofs: string[];
+        /** Additional facts/context */
+        facts?: Record<string, unknown>;
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+    }) => Promise<{
+        /** Content ID of the invocation */
+        cid: string;
+        /** Base64-encoded CAR bytes */
+        invocation: string;
+    }>;
+    /**
+     * Validate an invocation against its proof chain
+     */
+    validateInvocation?: (params: {
+        /** Base64-encoded CAR invocation */
+        invocation: string;
+        /** Base64-encoded CAR delegations (proofs) */
+        delegations: string[];
+    }) => Promise<{
+        valid: boolean;
+        error?: string;
+        /** Issuer DID if valid */
+        issuer?: string;
+        /** Validated capability if valid */
+        capability?: {
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        };
+    }>;
+    /**
+     * Parse a delegation from Base64 CAR format
+     */
+    parseDelegation?: (
+    /** Base64-encoded CAR delegation */
+    delegation: string) => Promise<{
+        cid: string;
+        issuer: string;
+        audience: string;
+        capabilities: Array<{
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        }>;
+        expiration?: number;
+        proofs: string[];
+    }>;
+    /**
+     * Search for users by name or DID
+     */
+    searchUsers?: (query: string) => Promise<Array<{
+        did: string;
+        displayName: string;
+        avatarUrl?: string;
+        address?: string;
+    }>>;
+    /**
+     * Get registered oracles for an entity
+     */
+    getRegisteredOracles?: (entityDid: string) => Promise<Array<{
+        did: string;
+        name: string;
+        description?: string;
+        capabilities?: string[];
+    }>>;
+    /**
+     * Get entity info including room ID
+     */
+    getEntityInfo?: (entityDid: string) => Promise<{
+        did: string;
+        name: string;
+        roomId: string;
+        adminAddress: string;
+        controllerDid: string;
+    }>;
+    /**
+     * Sign a Verifiable Credential using entity or user key.
+     * Creates a DataIntegrityProof using eddsa-rdfc-2022 cryptosuite.
+     */
+    signCredential?: (params: {
+        /** DID of issuer (entity or user) */
+        issuerDid: string;
+        /** Whether signing as entity or user */
+        issuerType: 'entity' | 'user';
+        /** Entity room ID (required if issuerType is 'entity') */
+        entityRoomId?: string;
+        /** The unsigned credential to sign */
+        credential: {
+            '@context': any;
+            id: string;
+            type: string[];
+            issuer: {
+                id: string;
+            };
+            validFrom: string;
+            validUntil: string;
+            credentialSchema: {
+                id: string;
+                type: string;
+            };
+            credentialSubject: any;
+        };
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+    }) => Promise<{
+        /** The signed credential with proof attached */
+        signedCredential: {
+            '@context': any;
+            id: string;
+            type: string[];
+            issuer: {
+                id: string;
+            };
+            validFrom: string;
+            validUntil: string;
+            credentialSchema: {
+                id: string;
+                type: string;
+            };
+            credentialSubject: any;
+            proof: {
+                type: 'DataIntegrityProof';
+                created: string;
+                verificationMethod: string;
+                cryptosuite: 'eddsa-rdfc-2022';
+                proofPurpose: 'assertionMethod';
+                proofValue: string;
+            };
+        };
+    }>;
+    /**
+     * Redirect to entity overview page
+     */
+    redirectToEntityOverview?: (did: string, type: string) => void;
+    /**
+     * Create a new domain entity with the provided linked resources.
+     * This is called after the domain card credential has been uploaded.
+     */
+    createDomain?: (params: {
+        /** Entity type from survey (e.g., 'dao', 'protocol') */
+        entityType: string;
+        /** Linked resources to attach to the entity (includes domain card) */
+        linkedResource: Array<{
+            id: string;
+            type: string;
+            proof: string;
+            right: string;
+            encrypted: string;
+            mediaType: string;
+            description: string;
+            serviceEndpoint: string;
+        }>;
+        /** Linked entities (e.g., governance groups) */
+        linkedEntity?: Array<{
+            id: string;
+            type: string;
+            relationship: string;
+            service: string;
+        }>;
+        /** Start date for the entity (from validFrom) */
+        startDate?: string;
+        /** End date for the entity (from validUntil) */
+        endDate?: string;
+    }) => Promise<{
+        /** The DID of the newly created entity */
+        entityDid: string;
+        /** Transaction hash */
+        transactionHash: string;
+    }>;
+    /**
+     * List available email templates from Mailgun
+     */
+    listEmailTemplates?: (params: {
+        limit?: number;
+        page?: string;
+    }) => Promise<{
+        items: Array<{
+            name: string;
+            description?: string;
+            createdAt: string;
+        }>;
+        paging?: {
+            first: string;
+            last: string;
+            next?: string;
+            previous?: string;
+        };
+    }>;
+    /**
+     * Get a specific email template with optional active version content
+     */
+    getEmailTemplate?: (params: {
+        templateName: string;
+        active?: boolean;
+    }) => Promise<{
+        name: string;
+        description?: string;
+        version?: {
+            tag: string;
+            template: string;
+            engine: string;
+            active: boolean;
+            createdAt: string;
+        };
+    }>;
+    /**
+     * Send an email using a template
+     */
+    sendEmail?: (params: {
+        to: string;
+        subject: string;
+        template: string;
+        templateVersion?: string;
+        variables?: Record<string, any>;
+        cc?: string;
+        bcc?: string;
+        replyTo?: string;
+    }) => Promise<{
+        id: string;
+        message: string;
+    }>;
+    /**
+     * Store a verifiable credential in Matrix room state.
+     * Used by the credential.store action type.
+     */
+    storeMatrixCredential?: (params: {
+        roomId: string;
+        credentialKey: string;
+        credential: Record<string, any>;
+        cid: string;
+    }) => Promise<{
+        storedAt: string;
+        duplicate: boolean;
+    }>;
+    /**
+     * Get the evaluation template linked resource for a deed
+     */
+    getEvaluationTemplate?: (deedDid: string, claimCollectionId?: string) => Promise<{
+        surveyTemplate: any;
+        claimCollectionId: string;
+    } | null>;
+    /**
+     * Get the rubric linked resource for a deed
+     */
+    getDeedRubric?: (deedDid: string) => Promise<{
+        rubric: any;
+        claimCollectionId: string;
+    } | null>;
+    /**
+     * Evaluate a claim using a rubric via the rubric engine
+     */
+    evaluateWithRubric?: (params: {
+        rubric: string;
+        claim: Record<string, any>;
+    }) => Promise<{
+        success: boolean;
+        trace?: {
+            traceId: string;
+            rubricVersion: number;
+            rubricName: string | null;
+            actor: {
+                type: 'ai' | 'human';
+                id?: string;
+            } | null;
+            result: {
+                outcome: 'pass' | 'fail' | 'escalated';
+                steps: Array<{
+                    stepId: string;
+                    kind: 'compute' | 'fetch' | 'check';
+                    success: boolean;
+                    outputs?: Record<string, any>;
+                    message?: string;
+                    error?: string;
+                    duration?: number;
+                    timestamp: string;
+                }>;
+                executionId: string;
+                startTime: string;
+                endTime: string;
+                totalDuration: number;
+                escalatedTo?: string;
+            };
+            claim: Record<string, any>;
+        };
+        error?: string;
+    }>;
+    /**
+     * Create a Universal Decentralized Identifier (UDID) for an evaluation result
+     */
+    createUdid?: (params: CreateUdidParams) => Promise<CreateUdidResponse>;
+    /**
+     * Create a new governance group (categorical, multisig, NFT staking, or token staking).
+     * The implementation is provided by the host application.
+     */
+    createGovernanceGroup?: (params: {
+        /** Type of governance group to create */
+        groupType: 'categorical' | 'multisig' | 'nftStaking' | 'tokenStaking';
+        /** Name of the group */
+        name: string;
+        /** Optional description */
+        description?: string;
+        /** Group-type specific configuration from the survey */
+        config: Record<string, unknown>;
+    }) => Promise<{
+        /** The DAO core contract address */
+        coreAddress: string;
+        /** The voting group contract address */
+        groupAddress: string;
+        /** Transaction hash */
+        transactionHash: string;
+    }>;
+    /**
+     * List entities where a given DID holds a specified role (e.g. 'controller').
+     * Used by the POD setup flow to list parent organisations the user can nest under.
+     */
+    getEntitiesByRole?: (params: {
+        /** DID of the actor */
+        did: string;
+        /** Role to filter by (e.g. 'controller', 'admin') */
+        role: string;
+    }) => Promise<Array<{
+        did: string;
+        name?: string;
+        /** IXO entity type string, e.g. 'dao/dao', 'dao/pod', 'protocol/deed' */
+        type?: string;
+        icon?: string;
+        description?: string;
+    }>>;
+    /**
+     * List flow templates available for a given blueprint entity.
+     * Used by the POD setup flow to let the user select startup flows.
+     */
+    getFlowTemplates?: (params: {
+        /** Entity DID of the blueprint/protocol */
+        entityDid: string;
+    }) => Promise<Array<{
+        did: string;
+        name?: string;
+        description?: string;
+    }>>;
+    /**
+     * Create a Cosmos governance group from explicit members and decision policy.
+     * Used by the POD setup flow after domain entity creation.
+     */
+    createGroup?: (params: {
+        /** The entity DID of the newly created domain (to associate the group) */
+        entityDid: string;
+        /** Members with roles and voting power */
+        members: Array<{
+            did: string;
+            role: string;
+            votingPower: number;
+        }>;
+        /** Decision policy parameters */
+        decisionPolicy: {
+            votingPeriod: string;
+            quorum: string;
+            threshold: string;
+            vetoThreshold: string;
+            minExecutionDelay: string;
+            executor: string;
+        };
+        /** Optional group name (defaults to entity name) */
+        name?: string;
+    }) => Promise<{
+        /** The group/DAO core contract address */
+        groupAddress: string;
+        /** Transaction hash */
+        transactionHash: string;
+    }>;
+    /**
+     * Navigate to a flow link URL
+     * @param url - HTTP URL of the target flow or page
+     */
+    navigateToFlow?: (url: string) => void;
+    /**
+     * Get the status of a flow document
+     * @param url - HTTP URL of the flow document
+     * @returns Flow status with optional completion timestamp
+     */
+    getFlowStatus?: (url: string) => Promise<{
+        status: 'not_started' | 'in_progress' | 'completed';
+        completedAt?: string;
+    }>;
+    /**
+     * Get workspace pages from protocol deed entity.
+     * The host app automatically determines the network context.
+     * @returns Array of workspace pages with type "Page" and mediaType "application/matrix"
+     */
+    getWorkspacePages?: () => Promise<WorkspacePage[]>;
+    /**
+     * Create a new signer session for handle-based signing.
+     *
+     * This allows the editor to request signing operations without receiving
+     * raw key material. The host app manages the session lifecycle and key security.
+     *
+     * @example
+     * ```typescript
+     * // Create a session-scoped signer for batch operations
+     * const session = await handlers.createSignerSession({
+     *   did: 'did:ixo:entity:abc123',
+     *   didType: 'entity',
+     *   entityRoomId: '!room:matrix.ixo.world',
+     *   pin: '123456',
+     *   scope: 'session',
+     *   ttlSeconds: 300
+     * });
+     *
+     * // Use for multiple signatures without re-entering PIN
+     * const sig1 = await handlers.signWithSession({ sessionId: session.sessionId, data: '...' });
+     * const sig2 = await handlers.signWithSession({ sessionId: session.sessionId, data: '...' });
+     *
+     * // Release when done
+     * await handlers.releaseSignerSession({ sessionId: session.sessionId });
+     * ```
+     */
+    createSignerSession?: (params: {
+        /** DID of the signer (entity or user) */
+        did: string;
+        /** Whether signing as entity or user */
+        didType: 'entity' | 'user';
+        /** Entity room ID (required if didType is 'entity') */
+        entityRoomId?: string;
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+        /**
+         * Session scope:
+         * - 'session': Remains valid for multiple sign operations until TTL or explicit release
+         * - 'operation': Automatically invalidated after first sign operation
+         */
+        scope: 'session' | 'operation';
+        /**
+         * Time-to-live in seconds (only applicable for 'session' scope)
+         * Default: 300 (5 minutes), Maximum: 3600 (1 hour)
+         */
+        ttlSeconds?: number;
+    }) => Promise<{
+        /** Opaque session identifier */
+        sessionId: string;
+        /** DID of the signer */
+        did: string;
+        /** Public key in multibase format (for verification) */
+        publicKey: string;
+        /** Key ID (verification method ID) */
+        keyId: string;
+        /** Unix timestamp when the session expires */
+        expiresAt: number;
+        /** The scope this session was created with */
+        scope: 'session' | 'operation';
+    }>;
+    /**
+     * Sign data using an existing signer session.
+     *
+     * For 'operation' scoped sessions, the session is automatically
+     * invalidated after this call succeeds.
+     *
+     * @throws If session not found, expired, or signing fails
+     */
+    signWithSession?: (params: {
+        /** The session ID returned from createSignerSession */
+        sessionId: string;
+        /** Data to sign (passed as-is to Ed25519 sign) */
+        data: string;
+        /** Algorithm hint (currently only Ed25519 supported) */
+        algorithm?: 'Ed25519';
+    }) => Promise<{
+        /** The signature in hex format */
+        signature: string;
+        /** The algorithm used */
+        algorithm: 'Ed25519';
+        /** Key ID that was used for signing */
+        keyId: string;
+    }>;
+    /**
+     * Release a signer session before it expires.
+     *
+     * This immediately clears the session from host memory, preventing
+     * any further signing operations. Idempotent - safe to call on
+     * already-expired or released sessions.
+     */
+    releaseSignerSession?: (params: {
+        /** The session ID to release */
+        sessionId: string;
+    }) => Promise<{
+        /** Whether the session was successfully released */
+        released: boolean;
+        /** Reason if not released (e.g., already expired) */
+        reason?: string;
+    }>;
+    /**
+     * Validate an MCP server URL and optionally authenticate with it.
+     * Returns the list of tools the server exposes on success.
+     */
+    validateMcpServer?: (params: {
+        url: string;
+        authType?: 'bearer' | 'api-key' | 'none';
+        authToken?: string;
+    }) => Promise<{
+        success: boolean;
+        tools?: Array<{
+            name: string;
+            description?: string;
+        }>;
+        error?: string;
+    }>;
+    /**
+     * Fetch available skills (capsules) from the skills registry
+     */
+    getNetwork?: () => Promise<string>;
+    getSkills?: () => Promise<{
+        capsules: Array<{
+            cid: string;
+            name: string;
+            description: string;
+            license: string;
+            compatibility: string;
+            allowedTools: string;
+            metadata: unknown;
+            archiveSize: number;
+            createdAt: string;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    }>;
+    /**
+     * Invoke a named skill with the given payload and return the result.
+     */
+    invokeSkill?: (skillName: string, payload: Record<string, unknown>) => Promise<unknown>;
+    deploySetup?: (params: {
+        name: string;
+        config: Record<string, any>;
+    }) => Promise<{
+        setupComplete: boolean;
+        stdout?: string;
+        stderr?: string;
+    }>;
+    deployStart?: (params: {
+        name: string;
+    }) => Promise<{
+        processId: string;
+        status: string;
+    }>;
+    integrations?: IntegrationsHandlers;
+    /**
+     * Bridge callback for the consuming app's analytics pipeline.
+     * Editor emits events using this callback so the portal can forward them to its analytics provider
+     * (e.g. PostHog) without the editor package taking a dependency on posthog-js.
+     */
+    onAnalyticsEvent?: (eventName: string, properties?: Record<string, unknown>) => void;
+}
+type DocType = 'template' | 'flow';
+/**
+ * Visualization renderer type for AG-UI integration.
+ * This function is called by visualization blocks to render the actual AG-UI component.
+ * @param vizType - The type of visualization (e.g., 'lineChart', 'barChart', 'dataTable', etc.)
+ * @param config - The configuration object for the visualization
+ * @param preferences - Optional user customizations (e.g., { pageSize: 25 }) persisted to the block
+ * @param onPreferencesChange - Optional callback to update preferences (persists via CRDT)
+ * @returns React node with the rendered visualization, or null if type is not supported
+ */
+type VisualizationRenderer = (vizType: string, config: object, preferences?: object, onPreferencesChange?: (prefs: object) => void) => React__default.ReactNode | null;
+/**
+ * Domain card data structure for rendering domain card previews
+ */
+interface DomainCardData {
+    name?: string;
+    summary?: string;
+    description?: string;
+    entity_type?: string[];
+    faq?: Array<{
+        question: string;
+        answer: string;
+    }>;
+    logo_url?: {
+        url?: string;
+        alt?: string;
+    };
+    image_urls?: Array<{
+        url: string;
+        alt: string;
+    }>;
+    keywords?: string[];
+    valid_from?: string;
+    issuer?: string;
+    area_served?: string;
+    address?: string;
+    coordinates?: {
+        type: string;
+        coordinates: [number, number];
+    };
+    contact?: {
+        email?: string;
+        website?: string;
+        location?: string;
+        socialLinks?: string[];
+    };
+    [key: string]: unknown;
+}
+/**
+ * Renderer for domain card previews in the qi/domain.card-preview action.
+ * The web app provides this renderer to display domain card data with proper styling.
+ */
+type DomainCardRenderer = (domainCardData: DomainCardData) => React__default.ReactNode;
+/**
+ * Dynamic list data returned by the data provider
+ */
+interface DynamicListData {
+    items: any[] | null;
+    loading: boolean;
+    error: string | null;
+}
+/**
+ * Function type for getting dynamic list data from context
+ */
+type DynamicListDataProvider = (listId: string) => DynamicListData;
+/**
+ * Dynamic list column definition (imported from types for context)
+ */
+interface DynamicListColumn {
+    key: string;
+    label: string;
+    position?: 'topLeft' | 'bottomLeft' | 'topRight' | 'bottomRight';
+    type?: 'string' | 'number' | 'date';
+    color?: string;
+}
+/**
+ * DataSource for dynamic lists
+ */
+interface DataSource {
+    oracleDid: string;
+    oracleName?: string;
+    query: string;
+    toolName?: string;
+    params?: Record<string, any>;
+    description?: string;
+}
+/**
+ * Action that can be performed on a dynamic list item
+ */
+interface DynamicListAction {
+    id: string;
+    label: string;
+    color?: string;
+}
+/**
+ * Panel renderer type for dynamic list selection panel.
+ * This function is called when an item is selected in a dynamic list.
+ * If provided, renders custom content. If not provided, shows default key-value view.
+ * @param item - The selected item data
+ * @param columns - Column definitions from the dynamic list
+ * @param dataSource - Data source info (oracle, query, etc.)
+ * @returns React node with custom panel content, or null to use default
+ */
+type DynamicListPanelRenderer = (item: any, columns: DynamicListColumn[], dataSource: DataSource | null, panelDescription?: string, actions?: DynamicListAction[], onClose?: () => void) => React__default.ReactNode | null;
+/**
+ * Translation function injected by the host app (e.g. next-i18next `t`).
+ * The editor stays framework-agnostic — when `translate` is not provided,
+ * `useTranslate` falls back to `defaultValue ?? key`, so all strings still
+ * render in English.
+ */
+type Translate = (key: string, opts?: {
+    defaultValue?: string;
+    [k: string]: any;
+}) => string;
+interface BlocknoteContextValue {
+    editor?: IxoEditorType;
+    handlers?: BlocknoteHandlers;
+    blockRequirements?: BlockRequirements;
+    mapConfig?: UnlMapConfig;
+    editable?: boolean;
+    docType: DocType;
+    /** Current flow schema version (e.g., '0.3', '1.0.0') */
+    flowVersion: string;
+    sharedProposals: SharedProposalData;
+    fetchSharedProposal: (proposalId: string, contractAddress: string, force?: boolean) => Promise<ProposalResponse>;
+    invalidateProposal: (proposalId: string) => void;
+    subscribeToProposal: (proposalId: string) => ProposalResponse | undefined;
+    activeDrawerId: string | null;
+    drawerContent: React__default.ReactNode | null;
+    openDrawer: (id: string, content: React__default.ReactNode) => void;
+    closeDrawer: () => void;
+    visualizationRenderer?: VisualizationRenderer;
+    getDynamicListData?: DynamicListDataProvider;
+    dynamicListPanelRenderer?: DynamicListPanelRenderer;
+    domainCardRenderer?: DomainCardRenderer;
+    connectedUsers?: Array<{
+        clientId: string;
+        state: any;
+    }>;
+    awarenessInstance?: any;
+    translate?: Translate;
+}
+declare const BlocknoteProvider: React__default.FC<{
+    children: React__default.ReactNode;
+    editor?: IxoEditorType;
+    handlers?: BlocknoteHandlers;
+    blockRequirements?: BlockRequirements;
+    editable?: boolean;
+    visualizationRenderer?: VisualizationRenderer;
+    getDynamicListData?: DynamicListDataProvider;
+    dynamicListPanelRenderer?: DynamicListPanelRenderer;
+    domainCardRenderer?: DomainCardRenderer;
+    mapConfig?: UnlMapConfig;
+    connectedUsers?: Array<{
+        clientId: string;
+        state: any;
+    }>;
+    awarenessInstance?: any;
+    translate?: Translate;
+}>;
+declare const useBlocknoteContext: () => BlocknoteContextValue;
+declare const useBlocknoteHandlers: () => BlocknoteHandlers;
+/**
+ * Translate function for editor strings. Reads `translate` from
+ * `BlocknoteContext`. When the host app hasn't provided one, falls back to
+ * `defaultValue ?? key` so the editor still renders something readable.
+ *
+ * The returned function has a stable identity across renders, so consumers
+ * can safely omit it from useEffect/useCallback dependency arrays. Internally
+ * it reads the latest `translate` via a ref, so language switches still
+ * trigger re-renders through the surrounding context update.
+ *
+ * Usage:
+ *   const t = useTranslate();
+ *   <span>{t('pageTitle.placeholder', { defaultValue: 'New page' })}</span>
+ */
+declare const useTranslate: () => Translate;
+
+interface SelectionActionItem {
+    id: string;
+    label: string;
+    icon?: string;
+    onClick: (itemId: string, itemData: any) => void | Promise<void>;
+}
+interface SelectionActionSection {
+    title: string;
+    description?: string;
+    actions: SelectionActionItem[];
+}
+
 declare const blockSpecs: {
     checkbox: {
         config: {
@@ -1863,7 +4289,7 @@ declare const blockSpecs: {
         }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
     };
 };
-declare const getExtraSlashMenuItems: (editor: any) => {
+declare const getExtraSlashMenuItems: (editor: any, translate?: Translate) => {
     title: string;
     icon: React.JSX.Element;
     onItemClick: () => void;
@@ -2844,4 +5270,4 @@ interface IxoEditorConfig {
     tableHandles: boolean;
 }
 
-export { type ExecutionWithInvocationResult as A, type FindProofsResult as B, type ClaimCollectionURI as C, type DelegationChainValidationResult as D, type EvaluationStatus as E, type FlowMetadata as F, type CreateRootDelegationParams as G, type CreateDelegationParams as H, type InvocationStore as I, type CreateInvocationParams as J, type IxoBlockProps as K, type LinkedClaim as L, type NodeState as N, type StoredDelegation as S, type UcanDelegationStore as U, createMemoryUcanDelegationStore as a, createInvocationStore as b, createUcanDelegationStore as c, createMemoryInvocationStore as d, createUcanService as e, type UcanService as f, type UcanServiceConfig as g, type UcanServiceHandlers as h, type UcanCapability as i, type StoredInvocation as j, type DelegationGrant as k, type IxoEditorOptions as l, type IxoEditorTheme as m, type IxoEditorConfig as n, type IxoCollaborativeUser as o, type IxoCollaborativeEditorOptions as p, blockSpecs as q, getExtraSlashMenuItems as r, type IxoEditorType as s, type FlowNode as t, type DID as u, type FlowNodeAuthzExtension as v, type FlowNodeRuntimeState as w, type FlowNodeBase as x, type InvocationRequest as y, type InvocationResult as z };
+export { type EvaluationStatus as $, AuthzExecActionTypes as A, BlocknoteProvider as B, type VoteResponse as C, type DelegationChainValidationResult as D, type VoteInfo as E, type Vote as F, type User as G, type Addr as H, type InvocationStore as I, type Uint128 as J, type Expiration as K, type Status as L, type Threshold as M, type Votes as N, type CosmosMsgForEmpty as O, type ProposalResponse as P, type ProposalAction as Q, type Translate as R, type StoredDelegation as S, type Timestamp as T, type UcanDelegationStore as U, ValidatorActionType as V, type IxoEditorType as W, type FlowMetadata as X, type FlowNode as Y, type DID as Z, type ClaimCollectionURI as _, createMemoryUcanDelegationStore as a, type LinkedClaim as a0, type FlowNodeAuthzExtension as a1, type FlowNodeRuntimeState as a2, type NodeState as a3, type FlowNodeBase as a4, type InvocationRequest as a5, type InvocationResult as a6, type ExecutionWithInvocationResult as a7, type FindProofsResult as a8, type CreateRootDelegationParams as a9, type CreateDelegationParams as aa, type CreateInvocationParams as ab, type IxoBlockProps as ac, type VisualizationRenderer as ad, type DynamicListData as ae, type DynamicListDataProvider as af, type DynamicListPanelRenderer as ag, type DomainCardRenderer as ah, type DomainCardData as ai, type UnlMapConfig as aj, createInvocationStore as b, createUcanDelegationStore as c, createMemoryInvocationStore as d, createUcanService as e, type UcanService as f, type UcanServiceConfig as g, type UcanServiceHandlers as h, type UcanCapability as i, type StoredInvocation as j, type DelegationGrant as k, type IxoEditorOptions as l, type IxoEditorTheme as m, type IxoEditorConfig as n, type IxoCollaborativeUser as o, type IxoCollaborativeEditorOptions as p, blockSpecs as q, getExtraSlashMenuItems as r, useBlocknoteHandlers as s, useTranslate as t, useBlocknoteContext as u, StakeType as v, type BlocknoteHandlers as w, type BlocknoteContextValue as x, type BlockRequirements as y, type SingleChoiceProposal as z };