@ixo/editor 2.4.0 → 2.6.0

package/dist/graphql-client-ppGpOvLH.d.ts

@@ -0,0 +1,3134 @@
+import * as _blocknote_core from '@blocknote/core';
+import { BlockSchemaFromSpecs, InlineContentSchema, StyleSchema, BlockNoteEditor, PartialBlock } from '@blocknote/core';
+import { Map, Array as Array$1, Text, Doc } from 'yjs';
+import React from 'react';
+import { MatrixClient } from 'matrix-js-sdk';
+
+declare const CheckboxBlockSpec: {
+    config: {
+        readonly type: "checkbox";
+        readonly propSchema: {
+            readonly checked: {
+                readonly default: false;
+            };
+            readonly allowedCheckers: {
+                readonly default: "all";
+            };
+            readonly initialChecked: {
+                readonly default: false;
+            };
+            readonly title: {
+                readonly default: "";
+            };
+            readonly description: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "square-check";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "inline";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "checkbox";
+        readonly propSchema: {
+            readonly checked: {
+                readonly default: false;
+            };
+            readonly allowedCheckers: {
+                readonly default: "all";
+            };
+            readonly initialChecked: {
+                readonly default: false;
+            };
+            readonly title: {
+                readonly default: "";
+            };
+            readonly description: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "square-check";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "inline";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+type CheckboxBlockProps = IxoBlockProps;
+
+declare const ListBlockSpec: {
+    config: {
+        readonly type: "list";
+        readonly propSchema: {
+            readonly listType: {
+                readonly default: "";
+            };
+            readonly sort: {
+                readonly default: "{}";
+            };
+            readonly filter: {
+                readonly default: "{}";
+            };
+            readonly filterOptions: {
+                readonly default: "{}";
+            };
+            readonly sortOptions: {
+                readonly default: "{}";
+            };
+            readonly listConfig: {
+                readonly default: "{}";
+            };
+            readonly icon: {
+                readonly default: "📋";
+            };
+        };
+        readonly content: "none";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "list";
+        readonly propSchema: {
+            readonly listType: {
+                readonly default: "";
+            };
+            readonly sort: {
+                readonly default: "{}";
+            };
+            readonly filter: {
+                readonly default: "{}";
+            };
+            readonly filterOptions: {
+                readonly default: "{}";
+            };
+            readonly sortOptions: {
+                readonly default: "{}";
+            };
+            readonly listConfig: {
+                readonly default: "{}";
+            };
+            readonly icon: {
+                readonly default: "📋";
+            };
+        };
+        readonly content: "none";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+interface ListBlockSettings {
+    listType: string | null;
+    listConfig: string;
+}
+interface ListBlockProps extends IxoBlockProps {
+}
+
+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;
+}
+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 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$1 {
+    id: string;
+    context: string;
+    relayerNode: string;
+    controller: string;
+    type: string;
+    startDate: string;
+    endDate: string;
+    metadata: string;
+    linkedResource: LinkedResource[];
+    settings: Record<string, LinkedResource>;
+    service: string;
+    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;
+}
+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 Transaction {
+    transactionHash: string;
+    typeUrl: string;
+    memo: string;
+    time: string;
+    description?: 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/Service Agent
+    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;
+};
+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 {
+    actionSections: SelectionActionSection[];
+}
+interface CollectionDetails extends Collection {
+    actionSections: SelectionActionSection[];
+}
+interface TransactionDetails extends Transaction {
+    actionSections: SelectionActionSection[];
+}
+interface InvestmentDetails extends Investment {
+    actionSections: SelectionActionSection[];
+}
+interface OracleDetails extends Oracle {
+    actionSections: SelectionActionSection[];
+}
+interface PODDetails extends POD {
+    actionSections: SelectionActionSection[];
+}
+interface ProposalDetails extends Proposal {
+    actionSections: SelectionActionSection[];
+}
+interface RequestDetails extends Request {
+    actionSections: SelectionActionSection[];
+}
+interface MemberDetails extends Member {
+    actionSections: SelectionActionSection[];
+}
+interface ValidatorDetails extends Validator {
+    actionSections: SelectionActionSection[];
+}
+interface LinkedResourceDetails extends LinkedResource {
+    actionSections: SelectionActionSection[];
+}
+interface DAOGroup {
+    id: string;
+    name: string;
+    coreAddress: string;
+}
+interface BlockRequirements {
+    proposal?: {
+        coreAddress: 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 BlocknoteHandlers {
+    getVote: (proposalContractAddress: string, proposalId: string, userAddress: string) => Promise<VoteResponse>;
+    getProposal: (proposalContractAddress: string, proposalId: string) => Promise<ProposalResponse>;
+    getCurrentUser: () => User;
+    getMatrixInfoPerDid: (did: string) => Promise<IUserMatrixProfile>;
+    getDaoGroupsIds: () => Promise<string[] | undefined>;
+    getDAOGroups: () => Promise<DAOGroup[]>;
+    getRelayerDid: () => string | undefined;
+    getEntityDid: () => string | undefined;
+    vote: ({ proposalId, rationale, vote, proposalContractAddress }: VoteParams) => Promise<void>;
+    createProposal: (params: CreateProposalParams) => Promise<string>;
+    getEntity: (did: string) => Promise<EntityResponse$1>;
+    getDomainCard: () => Promise<DomainCard>;
+    askCompanion: (prompt: string) => Promise<void>;
+    getAssets: (collectionDid: string, page: number, ownerAddress?: string) => Promise<{
+        data: Asset[];
+        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) => 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) => 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>;
+    getDeedSurveyTemplate: (deedDid: 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: (params: {
+        deedDid: string;
+    }) => Promise<ClaimCollectionResponse>;
+    getClaimsPerCollectionId: (params: GetClaimsPerCollectionIdParams) => Promise<Claim[]>;
+    getClaimsPerUserAddress: (params: GetClaimsPerUserAddressParams) => Promise<Claim[]>;
+    getClaimData: (collectionId: string, claimId: string) => Promise<any>;
+    evaluateClaim: (granteeAddress: string, did: string, payload: {
+        claimId: string;
+        collectionId: string;
+        adminAddress: string;
+        status?: number;
+        verificationProof: string;
+        amount?: Coin;
+    }) => Promise<void>;
+    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) => Promise<{
+        surveyTemplate: any;
+    } | null>;
+    getBidEvaluatorSurveyTemplate: (deedId: 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
+     */
+    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
+     */
+    verifyCapabilitySignature?: (params: {
+        /** Raw capability JSON */
+        capabilityRaw: string;
+        /** Expected issuer DID */
+        issuerDid: string;
+    }) => Promise<{
+        valid: boolean;
+        error?: 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;
+            };
+        };
+    }>;
+    /**
+     * 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;
+        }>;
+        /** 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;
+    }>;
+}
+type DocType = 'template' | 'page' | 'flow';
+interface BlocknoteContextValue {
+    editor?: IxoEditorType;
+    handlers?: BlocknoteHandlers;
+    blockRequirements?: BlockRequirements;
+    editable?: boolean;
+    docType: DocType;
+    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.ReactNode | null;
+    openDrawer: (id: string, content: React.ReactNode) => void;
+    closeDrawer: () => void;
+}
+declare const BlocknoteProvider: React.FC<{
+    children: React.ReactNode;
+    editor?: IxoEditorType;
+    handlers?: BlocknoteHandlers;
+    blockRequirements?: BlockRequirements;
+    editable?: boolean;
+}>;
+declare const useBlocknoteContext: () => BlocknoteContextValue;
+declare const useBlocknoteHandlers: () => BlocknoteHandlers;
+
+interface SelectionActionItem {
+    id: string;
+    label: string;
+    icon?: string;
+    onClick: (itemId: string, itemData: any) => void | Promise<void>;
+}
+interface SelectionActionSection {
+    title: string;
+    description?: string;
+    actions: SelectionActionItem[];
+}
+
+interface OverviewBlockProps {
+    block: any;
+    editor: any;
+}
+declare const OverviewBlock: {
+    config: {
+        readonly type: "overview";
+        readonly propSchema: {};
+        readonly content: "none";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "overview";
+        readonly propSchema: {};
+        readonly content: "none";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+declare const ProposalBlockSpec: {
+    config: {
+        readonly type: "proposal";
+        readonly propSchema: {
+            readonly status: {
+                readonly default: "draft";
+                readonly values: readonly ["draft", "open", "passed", "rejected", "executed", "closed", "execution_failed", "veto_timelock"];
+            };
+            readonly title: {
+                readonly default: "";
+            };
+            readonly description: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "file-text";
+            };
+            readonly proposalId: {
+                readonly default: "";
+            };
+            readonly actions: {
+                readonly default: "[]";
+            };
+            readonly voteEnabled: {
+                readonly default: true;
+            };
+            readonly voteTitle: {
+                readonly default: "";
+            };
+            readonly voteSubtitle: {
+                readonly default: "";
+            };
+            readonly voteIcon: {
+                readonly default: "checklist";
+            };
+            readonly daysLeft: {
+                readonly default: 0;
+            };
+            readonly proposalContractAddress: {
+                readonly default: "";
+            };
+            readonly coreAddress: {
+                readonly default: "";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "none";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "proposal";
+        readonly propSchema: {
+            readonly status: {
+                readonly default: "draft";
+                readonly values: readonly ["draft", "open", "passed", "rejected", "executed", "closed", "execution_failed", "veto_timelock"];
+            };
+            readonly title: {
+                readonly default: "";
+            };
+            readonly description: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "file-text";
+            };
+            readonly proposalId: {
+                readonly default: "";
+            };
+            readonly actions: {
+                readonly default: "[]";
+            };
+            readonly voteEnabled: {
+                readonly default: true;
+            };
+            readonly voteTitle: {
+                readonly default: "";
+            };
+            readonly voteSubtitle: {
+                readonly default: "";
+            };
+            readonly voteIcon: {
+                readonly default: "checklist";
+            };
+            readonly daysLeft: {
+                readonly default: 0;
+            };
+            readonly proposalContractAddress: {
+                readonly default: "";
+            };
+            readonly coreAddress: {
+                readonly default: "";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "none";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+type ProposalBlockProps = IxoBlockProps;
+
+declare const ApiRequestBlockSpec: {
+    config: {
+        readonly type: "apiRequest";
+        readonly propSchema: {
+            readonly title: {
+                readonly default: "";
+            };
+            readonly description: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "square-check";
+            };
+            readonly endpoint: {
+                readonly default: "";
+            };
+            readonly method: {
+                readonly default: "GET";
+            };
+            readonly headers: {
+                readonly default: "[]";
+            };
+            readonly body: {
+                readonly default: "[]";
+            };
+            readonly response: {
+                readonly default: "";
+            };
+            readonly status: {
+                readonly default: "idle";
+            };
+            readonly responseSchema: {
+                readonly default: "";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "inline";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "apiRequest";
+        readonly propSchema: {
+            readonly title: {
+                readonly default: "";
+            };
+            readonly description: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "square-check";
+            };
+            readonly endpoint: {
+                readonly default: "";
+            };
+            readonly method: {
+                readonly default: "GET";
+            };
+            readonly headers: {
+                readonly default: "[]";
+            };
+            readonly body: {
+                readonly default: "[]";
+            };
+            readonly response: {
+                readonly default: "";
+            };
+            readonly status: {
+                readonly default: "idle";
+            };
+            readonly responseSchema: {
+                readonly default: "";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "inline";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+type ApiRequestBlockProps = IxoBlockProps;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type KeyValuePair = {
+    key: string;
+    value: string;
+};
+
+declare const blockSpecs: {
+    checkbox: {
+        config: {
+            readonly type: "checkbox";
+            readonly propSchema: {
+                readonly checked: {
+                    readonly default: false;
+                };
+                readonly allowedCheckers: {
+                    readonly default: "all";
+                };
+                readonly initialChecked: {
+                    readonly default: false;
+                };
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "square-check";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "inline";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "checkbox";
+            readonly propSchema: {
+                readonly checked: {
+                    readonly default: false;
+                };
+                readonly allowedCheckers: {
+                    readonly default: "all";
+                };
+                readonly initialChecked: {
+                    readonly default: false;
+                };
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "square-check";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "inline";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    list: {
+        config: {
+            readonly type: "list";
+            readonly propSchema: {
+                readonly listType: {
+                    readonly default: "";
+                };
+                readonly sort: {
+                    readonly default: "{}";
+                };
+                readonly filter: {
+                    readonly default: "{}";
+                };
+                readonly filterOptions: {
+                    readonly default: "{}";
+                };
+                readonly sortOptions: {
+                    readonly default: "{}";
+                };
+                readonly listConfig: {
+                    readonly default: "{}";
+                };
+                readonly icon: {
+                    readonly default: "📋";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "list";
+            readonly propSchema: {
+                readonly listType: {
+                    readonly default: "";
+                };
+                readonly sort: {
+                    readonly default: "{}";
+                };
+                readonly filter: {
+                    readonly default: "{}";
+                };
+                readonly filterOptions: {
+                    readonly default: "{}";
+                };
+                readonly sortOptions: {
+                    readonly default: "{}";
+                };
+                readonly listConfig: {
+                    readonly default: "{}";
+                };
+                readonly icon: {
+                    readonly default: "📋";
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    enumChecklist: {
+        config: {
+            readonly type: "enumChecklist";
+            readonly propSchema: {
+                readonly listType: {
+                    readonly default: "";
+                };
+                readonly listConfig: {
+                    readonly default: "{}";
+                };
+                readonly selectedIds: {
+                    readonly default: "[]";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "enumChecklist";
+            readonly propSchema: {
+                readonly listType: {
+                    readonly default: "";
+                };
+                readonly listConfig: {
+                    readonly default: "{}";
+                };
+                readonly selectedIds: {
+                    readonly default: "[]";
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    overview: {
+        config: {
+            readonly type: "overview";
+            readonly propSchema: {};
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "overview";
+            readonly propSchema: {};
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    proposal: {
+        config: {
+            readonly type: "proposal";
+            readonly propSchema: {
+                readonly status: {
+                    readonly default: "draft";
+                    readonly values: readonly ["draft", "open", "passed", "rejected", "executed", "closed", "execution_failed", "veto_timelock"];
+                };
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "file-text";
+                };
+                readonly proposalId: {
+                    readonly default: "";
+                };
+                readonly actions: {
+                    readonly default: "[]";
+                };
+                readonly voteEnabled: {
+                    readonly default: true;
+                };
+                readonly voteTitle: {
+                    readonly default: "";
+                };
+                readonly voteSubtitle: {
+                    readonly default: "";
+                };
+                readonly voteIcon: {
+                    readonly default: "checklist";
+                };
+                readonly daysLeft: {
+                    readonly default: 0;
+                };
+                readonly proposalContractAddress: {
+                    readonly default: "";
+                };
+                readonly coreAddress: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "proposal";
+            readonly propSchema: {
+                readonly status: {
+                    readonly default: "draft";
+                    readonly values: readonly ["draft", "open", "passed", "rejected", "executed", "closed", "execution_failed", "veto_timelock"];
+                };
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "file-text";
+                };
+                readonly proposalId: {
+                    readonly default: "";
+                };
+                readonly actions: {
+                    readonly default: "[]";
+                };
+                readonly voteEnabled: {
+                    readonly default: true;
+                };
+                readonly voteTitle: {
+                    readonly default: "";
+                };
+                readonly voteSubtitle: {
+                    readonly default: "";
+                };
+                readonly voteIcon: {
+                    readonly default: "checklist";
+                };
+                readonly daysLeft: {
+                    readonly default: 0;
+                };
+                readonly proposalContractAddress: {
+                    readonly default: "";
+                };
+                readonly coreAddress: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    apiRequest: {
+        config: {
+            readonly type: "apiRequest";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "square-check";
+                };
+                readonly endpoint: {
+                    readonly default: "";
+                };
+                readonly method: {
+                    readonly default: "GET";
+                };
+                readonly headers: {
+                    readonly default: "[]";
+                };
+                readonly body: {
+                    readonly default: "[]";
+                };
+                readonly response: {
+                    readonly default: "";
+                };
+                readonly status: {
+                    readonly default: "idle";
+                };
+                readonly responseSchema: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "inline";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "apiRequest";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "square-check";
+                };
+                readonly endpoint: {
+                    readonly default: "";
+                };
+                readonly method: {
+                    readonly default: "GET";
+                };
+                readonly headers: {
+                    readonly default: "[]";
+                };
+                readonly body: {
+                    readonly default: "[]";
+                };
+                readonly response: {
+                    readonly default: "";
+                };
+                readonly status: {
+                    readonly default: "idle";
+                };
+                readonly responseSchema: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "inline";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    notify: {
+        config: {
+            readonly type: "notify";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "bell";
+                };
+                readonly channel: {
+                    readonly default: "email";
+                };
+                readonly to: {
+                    readonly default: "[]";
+                };
+                readonly cc: {
+                    readonly default: "[]";
+                };
+                readonly bcc: {
+                    readonly default: "[]";
+                };
+                readonly subject: {
+                    readonly default: "";
+                };
+                readonly body: {
+                    readonly default: "";
+                };
+                readonly bodyType: {
+                    readonly default: "text";
+                };
+                readonly from: {
+                    readonly default: "";
+                };
+                readonly replyTo: {
+                    readonly default: "";
+                };
+                readonly templateId: {
+                    readonly default: "";
+                };
+                readonly templateVariables: {
+                    readonly default: "{}";
+                };
+                readonly status: {
+                    readonly default: "idle";
+                };
+                readonly messageId: {
+                    readonly default: "";
+                };
+                readonly sentAt: {
+                    readonly default: "";
+                };
+                readonly errorMessage: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "inline";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "notify";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "bell";
+                };
+                readonly channel: {
+                    readonly default: "email";
+                };
+                readonly to: {
+                    readonly default: "[]";
+                };
+                readonly cc: {
+                    readonly default: "[]";
+                };
+                readonly bcc: {
+                    readonly default: "[]";
+                };
+                readonly subject: {
+                    readonly default: "";
+                };
+                readonly body: {
+                    readonly default: "";
+                };
+                readonly bodyType: {
+                    readonly default: "text";
+                };
+                readonly from: {
+                    readonly default: "";
+                };
+                readonly replyTo: {
+                    readonly default: "";
+                };
+                readonly templateId: {
+                    readonly default: "";
+                };
+                readonly templateVariables: {
+                    readonly default: "{}";
+                };
+                readonly status: {
+                    readonly default: "idle";
+                };
+                readonly messageId: {
+                    readonly default: "";
+                };
+                readonly sentAt: {
+                    readonly default: "";
+                };
+                readonly errorMessage: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "inline";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    claim: {
+        config: {
+            readonly type: "claim";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "square-check";
+                };
+                readonly deedDid: {
+                    readonly default: "";
+                };
+                readonly selectedCollections: {
+                    readonly default: "[]";
+                };
+                readonly adminAddress: {
+                    readonly default: "";
+                };
+                readonly claimCollectionId: {
+                    readonly default: "";
+                };
+                readonly parentCapability: {
+                    readonly default: "";
+                };
+                readonly authorisedActors: {
+                    readonly default: "";
+                };
+                readonly linkedClaimCollectionId: {
+                    readonly default: "";
+                };
+                readonly activationUpstreamNodeId: {
+                    readonly default: "";
+                };
+                readonly activationRequiredStatus: {
+                    readonly default: "";
+                };
+                readonly activationRequireAuthorisedActor: {
+                    readonly default: false;
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "claim";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "square-check";
+                };
+                readonly deedDid: {
+                    readonly default: "";
+                };
+                readonly selectedCollections: {
+                    readonly default: "[]";
+                };
+                readonly adminAddress: {
+                    readonly default: "";
+                };
+                readonly claimCollectionId: {
+                    readonly default: "";
+                };
+                readonly parentCapability: {
+                    readonly default: "";
+                };
+                readonly authorisedActors: {
+                    readonly default: "";
+                };
+                readonly linkedClaimCollectionId: {
+                    readonly default: "";
+                };
+                readonly activationUpstreamNodeId: {
+                    readonly default: "";
+                };
+                readonly activationRequiredStatus: {
+                    readonly default: "";
+                };
+                readonly activationRequireAuthorisedActor: {
+                    readonly default: false;
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    bid: {
+        config: {
+            readonly type: "bid";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly did: {
+                    readonly default: "";
+                };
+                readonly selectedCollections: {
+                    readonly default: "[]";
+                };
+                readonly adminAddress: {
+                    readonly default: "";
+                };
+                readonly parentCapability: {
+                    readonly default: "";
+                };
+                readonly authorisedActors: {
+                    readonly default: "";
+                };
+                readonly linkedClaimCollectionId: {
+                    readonly default: "";
+                };
+                readonly activationUpstreamNodeId: {
+                    readonly default: "";
+                };
+                readonly activationRequiredStatus: {
+                    readonly default: "";
+                };
+                readonly activationRequireAuthorisedActor: {
+                    readonly default: false;
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "bid";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly did: {
+                    readonly default: "";
+                };
+                readonly selectedCollections: {
+                    readonly default: "[]";
+                };
+                readonly adminAddress: {
+                    readonly default: "";
+                };
+                readonly parentCapability: {
+                    readonly default: "";
+                };
+                readonly authorisedActors: {
+                    readonly default: "";
+                };
+                readonly linkedClaimCollectionId: {
+                    readonly default: "";
+                };
+                readonly activationUpstreamNodeId: {
+                    readonly default: "";
+                };
+                readonly activationRequiredStatus: {
+                    readonly default: "";
+                };
+                readonly activationRequireAuthorisedActor: {
+                    readonly default: false;
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    evaluator: {
+        config: {
+            readonly type: "evaluator";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "checklist";
+                };
+                readonly deedDid: {
+                    readonly default: "";
+                };
+                readonly selectedCollections: {
+                    readonly default: "[]";
+                };
+                readonly adminAddress: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "evaluator";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "checklist";
+                };
+                readonly deedDid: {
+                    readonly default: "";
+                };
+                readonly selectedCollections: {
+                    readonly default: "[]";
+                };
+                readonly adminAddress: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    domainCreator: {
+        config: {
+            readonly type: "domainCreator";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "file-text";
+                };
+                readonly surveySchema: {
+                    readonly default: "";
+                };
+                readonly answers: {
+                    readonly default: "";
+                };
+                readonly lastSubmission: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "domainCreator";
+            readonly propSchema: {
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly description: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "file-text";
+                };
+                readonly surveySchema: {
+                    readonly default: "";
+                };
+                readonly answers: {
+                    readonly default: "";
+                };
+                readonly lastSubmission: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+};
+declare const getExtraSlashMenuItems: (editor: any) => {
+    title: string;
+    onItemClick: () => void;
+    aliases: string[];
+    group: string;
+    subtext: string;
+}[];
+
+/**
+ * Page metadata stored in Matrix state events
+ * Now stores only URL strings in separate events
+ */
+interface PageMetadata {
+    /** Cover image URL */
+    cover?: string;
+    /** Icon/logo image URL */
+    icon?: string;
+}
+/**
+ * Callback type for metadata change subscriptions
+ */
+type MetadataChangeCallback = (metadata: PageMetadata) => void;
+/**
+ * Manager for Matrix state events containing page metadata (cover, icon)
+ *
+ * Stores cover and icon as separate state events, each containing only the URL string.
+ */
+declare class MatrixMetadataManager {
+    private matrixClient;
+    private roomId;
+    private subscribers;
+    private eventHandler;
+    constructor(matrixClient: MatrixClient, roomId: string);
+    /**
+     * Set up Matrix event listener for real-time updates
+     */
+    private setupEventListener;
+    /**
+     * Notify all subscribers of metadata changes
+     */
+    private notifySubscribers;
+    /**
+     * Send metadata to Matrix state events (separate events for cover and icon)
+     *
+     * @param metadata - The metadata to store (only URL strings)
+     * @param permissions - Permission check object
+     * @returns Promise that resolves when state events are sent
+     */
+    setMetadata(metadata: PageMetadata, permissions: {
+        write: boolean;
+    }): Promise<void>;
+    /**
+     * Get current metadata from Matrix state (reads from separate events)
+     *
+     * @returns Current metadata or null if not set
+     */
+    getMetadata(): PageMetadata | null;
+    /**
+     * Subscribe to metadata changes
+     *
+     * @param callback - Function to call when metadata changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: MetadataChangeCallback): () => void;
+    /**
+     * Clean up event listeners and subscriptions
+     * Call this when the manager is no longer needed
+     */
+    dispose(): void;
+}
+
+type CapabilityURI = string;
+type DID = string;
+type ClaimCollectionURI = string;
+type EvaluationStatus = 'pending' | 'approved' | 'rejected';
+interface LinkedClaim {
+    collectionId: ClaimCollectionURI;
+}
+interface ActivationCondition {
+    upstreamNodeId: string;
+    requiredStatus: EvaluationStatus;
+    requireAuthorisedActor?: boolean;
+}
+interface FlowNodeAuthzExtension {
+    parentCapability?: CapabilityURI;
+    authorisedActors?: DID[];
+    linkedClaim?: LinkedClaim;
+    activationCondition?: ActivationCondition;
+}
+interface FlowNodeRuntimeState {
+    claimId?: string;
+    submittedByDid?: DID;
+    evaluationStatus?: EvaluationStatus;
+    executionTimestamp?: number;
+    derivedUcan?: string;
+    authorisedActorsSnapshot?: DID[];
+}
+interface FlowNodeBase {
+    id: string;
+    type: string;
+    props: Record<string, any>;
+}
+type FlowNode = FlowNodeBase & FlowNodeAuthzExtension;
+
+/**
+ * Capability types for UCAN-based authorization
+ */
+interface Capability {
+    /** Action that can be performed, e.g., "flow/execute", "flow/block/execute" */
+    can: string;
+    /** Resource URI, e.g., "ixo:flow:abc123", "ixo:flow:abc123:blockId" */
+    with: string;
+    /** Additional constraints (optional) */
+    nb?: Record<string, any>;
+}
+interface SignedCapability {
+    /** Unique identifier (CID or generated ID) */
+    id: string;
+    /** DID of the issuer (entity or user who signed) */
+    issuer: string;
+    /** DID of the recipient */
+    audience: string;
+    /** Capabilities being granted */
+    capabilities: Capability[];
+    /** IDs of parent capabilities in the chain (empty for root) */
+    proofs: string[];
+    /** Unix timestamp when capability expires (optional) */
+    expiration?: number;
+    /** ISO timestamp when created */
+    issuedAt: string;
+    /** Base64 encoded signature */
+    signature: string;
+}
+interface CapabilityValidationResult {
+    valid: boolean;
+    error?: string;
+    /** The full chain from root to the validated capability */
+    chain?: SignedCapability[];
+}
+interface DelegationGrant {
+    /** DID of recipient */
+    audience: string;
+    /** Display name of recipient (for UI) */
+    audienceDisplayName?: string;
+    /** Capabilities to grant */
+    capabilities: Capability[];
+    /** IDs of proof capabilities */
+    proofs: string[];
+    /** Expiration timestamp (optional) */
+    expiration?: number;
+    /** Whether recipient can further delegate */
+    canDelegate?: boolean;
+}
+
+/**
+ * The schema type for the IXO editor, derived from block specs
+ */
+type IxoBlockSchema = BlockSchemaFromSpecs<typeof blockSpecs>;
+/**
+ * Editor mode representing different use cases
+ */
+type EditorMode = 'flow' | 'template' | 'readonly';
+/**
+ * Flow metadata stored in the Y.Doc root map
+ */
+interface FlowMetadata {
+    '@context': string;
+    _type: string;
+    schema_version: string;
+    doc_id: string;
+    title: string;
+    createdAt: string;
+    createdBy: string;
+    /** DID of the flow owner who has root signing authority */
+    flowOwnerDid: string;
+}
+/**
+ * Image data returned from publicFileUpload handler
+ */
+interface ImageData {
+    url: string;
+    cid: string;
+    encrypted: string;
+    proof: string;
+    serviceEndpoint: string;
+    mxc: string;
+}
+/**
+ * Extended editor type that augments BlockNoteEditor with IXO-specific properties
+ * and methods. This type should be used throughout the application instead of
+ * the base BlockNoteEditor type.
+ *
+ * Type Parameters:
+ * - BSchema: The block schema (defaults to IxoBlockSchema)
+ * - ISchema: The inline content schema (uses BlockNote defaults)
+ * - SSchema: The style schema (uses BlockNote defaults)
+ */
+interface IxoEditorType<BSchema extends IxoBlockSchema = IxoBlockSchema, ISchema extends InlineContentSchema = InlineContentSchema, SSchema extends StyleSchema = StyleSchema> extends BlockNoteEditor<BSchema, ISchema, SSchema> {
+    /**
+     * Configuration options for the editor
+     * @internal
+     */
+    _ixoConfig: IxoEditorConfig;
+    /**
+     * Y.Doc root map for collaborative metadata storage
+     * @internal
+     */
+    _yRoot?: Map<any>;
+    /**
+     * Y.Array for flow-specific structured block storage
+     * @internal
+    */
+    _yFlow?: Array$1<any>;
+    /**
+     * Y.Map for runtime per-node state (claim status, timestamps, etc.)
+     * @internal
+     */
+    _yRuntime?: Map<any>;
+    /**
+     * Y.Map for storing capability delegations
+     * @internal
+     */
+    _yDelegations?: Map<any>;
+    /**
+     * Current editor mode (flow, template, readonly)
+     */
+    mode?: EditorMode;
+    /**
+     * Current user information (for collaborative editing)
+     */
+    user?: IxoCollaborativeUser;
+    /**
+     * Document type (template, flow, page)
+     * This is a local prop-based value, NOT synced via CRDT
+     */
+    docType?: 'template' | 'flow' | 'page';
+    /**
+     * Get user-specific properties for a block
+     * @param block - The block to get user properties for
+     * @returns User-specific properties object
+     */
+    getUserProps?: (block: any) => Record<string, any>;
+    /**
+     * Update user-specific properties for a block
+     * @param block - The block to update
+     * @param updates - Properties to update
+     */
+    updateUserProps?: (block: any, updates: Record<string, any>) => void;
+    /**
+     * Get flow-level metadata
+     * @returns Flow metadata object
+     */
+    getFlowMetadata?: () => FlowMetadata;
+    /**
+     * Update flow-level metadata
+     * @param updates - Metadata fields to update
+     */
+    updateFlowMetadata?: (updates: Partial<FlowMetadata>) => void;
+    /**
+     * Get the DID of the flow owner (who has root signing authority)
+     * @returns Flow owner DID or empty string if not set
+     */
+    getFlowOwnerDid?: () => string;
+    /**
+     * Get the flow array (structured block storage)
+     * @returns Array of flow blocks
+     */
+    getFlow?: () => any[];
+    /**
+     * Retrieve a flow node by id from the structured flow array if available.
+     */
+    getFlowNode?: (nodeId: string) => FlowNode | null;
+    /**
+     * Get a delegation by ID
+     */
+    getDelegation?: (capabilityId: string) => SignedCapability | null;
+    /**
+     * Store a delegation
+     */
+    setDelegation?: (capability: SignedCapability) => void;
+    /**
+     * Get the root capability for this flow
+     */
+    getRootCapability?: () => SignedCapability | null;
+    /**
+     * Set the root capability ID
+     */
+    setRootCapabilityId?: (capabilityId: string) => void;
+    /**
+     * Get all delegations as array
+     */
+    getAllDelegations?: () => SignedCapability[];
+    /**
+     * Remove a delegation (revoke)
+     */
+    removeDelegation?: (capabilityId: string) => void;
+    /**
+     * Matrix metadata manager for page metadata (cover, icon)
+     * @internal
+     */
+    _metadataManager?: MatrixMetadataManager;
+    /**
+     * Set page metadata (cover image and/or icon)
+     * @param metadata - Partial metadata to update (merges with existing)
+     * @returns Promise that resolves when metadata is updated
+     */
+    setPageMetadata?: (metadata: Partial<PageMetadata>) => Promise<void>;
+    /**
+     * Get current page metadata (cover image and icon)
+     * @returns Current metadata or null if not set
+     */
+    getPageMetadata?: () => PageMetadata | null;
+    /**
+     * @deprecated Use setPageMetadata({ cover: imageData }) instead
+     */
+    setCoverImage?: (imageData?: ImageData) => void;
+    /**
+     * @deprecated Use getPageMetadata()?.cover instead
+     */
+    getCoverImage?: () => ImageData | undefined;
+    /**
+     * @deprecated Use setPageMetadata({ icon: imageData }) instead
+     */
+    setLogo?: (imageData?: ImageData) => void;
+    /**
+     * @deprecated Use getPageMetadata()?.icon instead
+     */
+    getLogo?: () => ImageData | undefined;
+}
+/**
+ * Re-map BlockNote renderer props to use IxoEditorType instead of BlockNoteEditor.
+ * This is used in block renderers to ensure they receive the augmented editor type.
+ *
+ * @example
+ * ```typescript
+ * export function MyBlock(props: IxoBlockProps) {
+ *   const { block, editor } = props;
+ *   // editor is now IxoEditorType with full type safety
+ *   console.log(editor.user?.name);
+ * }
+ * ```
+ */
+interface IxoBlockProps<TBlock = any> {
+    editor: IxoEditorType;
+    block: TBlock;
+}
+
+type IxoEditorTheme = 'light' | 'dark';
+interface IxoEditorOptions {
+    /**
+     * The color theme for the editor
+     * @default 'light'
+     */
+    theme?: IxoEditorTheme;
+    /**
+     * Function to handle file uploads
+     */
+    uploadFile?: (file: File) => Promise<string>;
+    /**
+     * Initial content for the editor
+     */
+    initialContent?: PartialBlock[];
+    /**
+     * Whether the editor is editable
+     * @default true
+     */
+    editable?: boolean;
+    /**
+     * Whether to show the side menu (drag handle, plus button)
+     * @default true
+     */
+    sideMenu?: boolean;
+    /**
+     * Whether to enable the slash menu
+     * @default true
+     */
+    slashMenu?: boolean;
+    /**
+     * Whether to show the formatting toolbar
+     * @default true
+     */
+    formattingToolbar?: boolean;
+    /**
+     * Whether to show the link toolbar
+     * @default true
+     */
+    linkToolbar?: boolean;
+    /**
+     * Whether to show the file panel
+     * @default true
+     */
+    filePanel?: boolean;
+    /**
+     * Whether to show table handles
+     * @default true
+     */
+    tableHandles?: boolean;
+    /**
+     * Document type (template, flow, page)
+     * This is a local prop and NOT synced via CRDT
+     * @default 'flow'
+     */
+    docType?: 'template' | 'flow' | 'page';
+}
+interface IxoCollaborativeUser {
+    name: string;
+    color: string;
+    accessToken: string;
+    address: string;
+    id: string;
+}
+interface IxoCollaborativeEditorPermissions {
+    /**
+     * Whether the user has write permissions
+     * @default false
+     */
+    write: boolean;
+}
+interface IxoCollaborativeEditorOptions extends IxoEditorOptions {
+    user: IxoCollaborativeUser;
+    matrixClient: MatrixClient;
+    roomId: string;
+    /**
+     * User permissions for the collaborative document
+     * @default { write: false }
+     */
+    permissions?: IxoCollaborativeEditorPermissions;
+    /**
+     * Unique identifier for the document/flow
+     */
+    docId?: string;
+    /**
+     * Title of the flow document
+     */
+    title?: string;
+}
+interface IxoEditorConfig {
+    theme: IxoEditorTheme;
+    editable: boolean;
+    sideMenu: boolean;
+    slashMenu: boolean;
+    formattingToolbar: boolean;
+    linkToolbar: boolean;
+    filePanel: boolean;
+    tableHandles: boolean;
+}
+
+/**
+ * Custom hook that wraps useCreateBlockNote with IXO-specific configurations (Mantine version)
+ * @param options - Configuration options for the IxoEditor
+ * @returns A configured IxoEditor instance with augmented type properties
+ */
+declare function useCreateIxoEditor(options?: IxoEditorOptions): IxoEditorType | undefined;
+
+/**
+ * Custom hook that wraps useCreateBlockNote with IXO-specific configurations (Mantine version)
+ * @param options - Configuration options for the IxoEditor
+ * @returns A configured collaborative IxoEditor instance with augmented type properties
+ */
+declare function useCreateCollaborativeIxoEditor(options: IxoCollaborativeEditorOptions): {
+    editor: IxoEditorType | undefined;
+    connectionStatus: string;
+    title: Text;
+    yDoc: Doc;
+    root: Map<any>;
+    flowArray: Array$1<any>;
+};
+
+interface PageHeaderMenuItem {
+    label: string;
+    onClick: () => void;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    divider?: boolean;
+}
+interface PageHeaderProps {
+    title?: string;
+    icon?: React.ReactNode;
+    isPrivate?: boolean;
+    lastEdited?: string;
+    onShare?: () => void;
+    onFavorite?: () => void;
+    isFavorited?: boolean;
+    menuItems?: PageHeaderMenuItem[];
+}
+/**
+ * PageHeader component - A Notion-style page header with title, privacy badge, and actions
+ */
+declare function PageHeader({ title, icon, isPrivate, lastEdited, onShare, onFavorite, isFavorited, menuItems, }: PageHeaderProps): React.ReactElement;
+
+interface IxoEditorProps {
+    editor: IxoEditorType | undefined;
+    editable?: boolean;
+    className?: string;
+    onChange?: () => void;
+    onSelectionChange?: () => void;
+    children?: React.ReactNode;
+    mantineTheme?: any;
+    handlers?: BlocknoteHandlers;
+    blockRequirements?: BlockRequirements;
+    isPanelVisible?: boolean;
+    coverImageUrl?: string;
+    logoUrl?: string;
+    selfNav?: boolean;
+    pageHeaderProps?: Omit<PageHeaderProps, 'children'>;
+}
+/**
+ * IxoEditor component - A customized BlockNote editor for IXO (Mantine UI)
+ */
+declare function IxoEditor({ editor, editable, className, onChange, onSelectionChange, children, mantineTheme, handlers, blockRequirements, isPanelVisible, coverImageUrl, logoUrl, selfNav, pageHeaderProps, }: IxoEditorProps): React.ReactElement | null;
+
+interface CoverImageProps {
+    coverImageUrl?: string;
+    logoUrl?: string;
+}
+/**
+ * CoverImage component - Notion-like cover image with logo
+ */
+declare function CoverImage({ coverImageUrl, logoUrl }: CoverImageProps): React.ReactElement | null;
+
+type AuthorizationTabState = {
+    parentCapability: string;
+    authorisedActors: string;
+    activationUpstreamNodeId: string;
+    activationRequiredStatus: 'pending' | 'approved' | 'rejected' | '';
+    activationRequireAuthorisedActor: boolean;
+};
+interface AuthorizationTabProps extends IxoBlockProps {
+    /** Flow URI for capability scoping */
+    flowUri?: string;
+    /** Entity DID that owns this flow */
+    entityDid?: string;
+    /** Flow permissions (actors with flow-level access) */
+    flowActors?: Array<{
+        did: string;
+        displayName: string;
+    }>;
+    /** Callback to open flow permissions panel */
+    onOpenFlowPermissions?: () => void;
+}
+declare const AuthorizationTab: React.FC<AuthorizationTabProps>;
+
+type EvaluationTabState = {
+    linkedClaimCollectionId: string;
+};
+interface EvaluationTabProps extends IxoBlockProps {
+}
+declare const EvaluationTab: React.FC<EvaluationTabProps>;
+
+interface EntitySigningSetupProps {
+    opened: boolean;
+    onClose: () => void;
+    entityDid: string;
+    entityName?: string;
+    onSetup: (pin: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+declare const EntitySigningSetup: React.FC<EntitySigningSetupProps>;
+
+interface FlowPermissionsPanelProps {
+    editor: IxoEditorType;
+    entityDid: string;
+    entityName?: string;
+    currentUserDid: string;
+    onGrantPermission: () => void;
+    onRevokePermission: (capabilityId: string) => Promise<void>;
+    getUserDisplayName?: (did: string) => Promise<string>;
+}
+declare const FlowPermissionsPanel: React.FC<FlowPermissionsPanelProps>;
+
+interface GrantPermissionModalProps {
+    opened: boolean;
+    onClose: () => void;
+    flowUri: string;
+    /** Blocks available for scope selection. If single block, scope UI is hidden. */
+    blocks: Array<{
+        id: string;
+        type: string;
+        name?: string;
+    }>;
+    /** Optional: specific block to grant permission for (hides scope selection) */
+    targetBlockId?: string;
+    searchUsers: (query: string) => Promise<Array<{
+        did: string;
+        displayName: string;
+        avatarUrl?: string;
+    }>>;
+    getOracles?: () => Promise<Array<{
+        did: string;
+        name: string;
+    }>>;
+    onGrant: (grant: DelegationGrant, pin: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+declare const GrantPermissionModal: React.FC<GrantPermissionModalProps>;
+
+/**
+ * GraphQL queries and types for IXO network
+ */
+interface Entity {
+    context: string;
+    relayerNode: string;
+    controller: string;
+    id: string;
+    type: string;
+    startDate: string;
+    endDate: string;
+    metadata: string;
+    linkedResource: any[];
+    settings: Record<string, Record<string, any>>;
+    service: string;
+    externalId: string;
+}
+interface EntityResponse {
+    entity: Entity;
+}
+interface EntityVariables {
+    entityId: string;
+}
+/**
+ * Fetches entity data by ID from the IXO network
+ * @param entityId - The unique identifier for the entity
+ * @returns Promise resolving to the entity data
+ */
+declare function getEntity(entityId: string): Promise<Entity>;
+
+/**
+ * Lightweight GraphQL client for IXO network queries
+ */
+interface GraphQLResponse<T = any> {
+    data?: T;
+    errors?: Array<{
+        message: string;
+        locations?: Array<{
+            line: number;
+            column: number;
+        }>;
+        path?: Array<string | number>;
+    }>;
+}
+interface GraphQLRequest {
+    query: string;
+    variables?: Record<string, any>;
+    operationName?: string;
+}
+declare class GraphQLClient {
+    private endpoint;
+    private headers;
+    constructor(endpoint: string, headers?: Record<string, string>);
+    request<T = any>(request: GraphQLRequest): Promise<T>;
+}
+declare const ixoGraphQLClient: GraphQLClient;
+
+export { type VoteResponse as $, AuthorizationTab as A, type OverviewBlockProps as B, type Capability as C, type DelegationGrant as D, type EvaluationStatus as E, type FlowNode as F, GrantPermissionModal as G, type ProposalBlockProps as H, type IxoEditorType as I, type ApiRequestBlockProps as J, type HttpMethod as K, ListBlockSpec as L, type KeyValuePair as M, BlocknoteProvider as N, OverviewBlock as O, ProposalBlockSpec as P, useBlocknoteContext as Q, useBlocknoteHandlers as R, type SignedCapability as S, StakeType as T, AuthzExecActionTypes as U, ValidatorActionType as V, type BlocknoteHandlers as W, type BlocknoteContextValue as X, type BlockRequirements as Y, type ProposalResponse as Z, type SingleChoiceProposal as _, type FlowNodeAuthzExtension as a, type VoteInfo as a0, type Vote as a1, type User as a2, type Addr as a3, type Uint128 as a4, type Timestamp as a5, type Expiration as a6, type Status as a7, type Threshold as a8, type Votes as a9, type CosmosMsgForEmpty as aa, type ProposalAction as ab, getEntity as ac, type Entity as ad, type EntityResponse as ae, type EntityVariables as af, GraphQLClient as ag, ixoGraphQLClient as ah, type GraphQLResponse as ai, type GraphQLRequest as aj, PageHeader as ak, type PageHeaderProps as al, type PageHeaderMenuItem as am, type FlowNodeRuntimeState as b, type CapabilityValidationResult as c, useCreateCollaborativeIxoEditor as d, IxoEditor as e, type IxoEditorProps as f, CoverImage as g, type CoverImageProps as h, type AuthorizationTabState as i, EvaluationTab as j, type EvaluationTabState as k, EntitySigningSetup as l, FlowPermissionsPanel as m, type IxoEditorOptions as n, type IxoEditorTheme as o, type IxoEditorConfig as p, type IxoCollaborativeUser as q, type IxoCollaborativeEditorOptions as r, CheckboxBlockSpec as s, ApiRequestBlockSpec as t, useCreateIxoEditor as u, blockSpecs as v, getExtraSlashMenuItems as w, type CheckboxBlockProps as x, type ListBlockSettings as y, type ListBlockProps as z };