import * as _blocknote_core from '@blocknote/core';
import { J as IxoBlockProps, s as IxoEditorType, l as IxoEditorOptions, p as IxoCollaborativeEditorOptions, k as DelegationGrant } from './index-CNCZs4wP.mjs';
import { Text, Doc, Map, Array as Array$1 } from 'yjs';
import React__default 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 ttlAbsoluteDueDate: {
                readonly default: "";
            };
            readonly ttlFromEnablement: {
                readonly default: "";
            };
            readonly ttlFromCommitment: {
                readonly default: "";
            };
            readonly skill: {
                readonly default: "";
            };
        };
        readonly content: "none";
    };
    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 ttlAbsoluteDueDate: {
                readonly default: "";
            };
            readonly ttlFromEnablement: {
                readonly default: "";
            };
            readonly ttlFromCommitment: {
                readonly default: "";
            };
            readonly skill: {
                readonly default: "";
            };
        };
        readonly content: "none";
    }, 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 skill: {
                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 skill: {
                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 AwarenessDocActor = {
    name: string;
    did: string;
    src: string | null;
};
type IUserMatrixProfile = {
    walletAddress: string;
    displayname: string;
    avatarUrl: string | null;
    did: string;
    verified?: boolean;
};
interface LinkedResource {
    id: string;
    type: string;
    proof: string;
    right: string;
    encrypted: string;
    mediaType: string;
    description: string;
    serviceEndpoint: string;
}
interface Service {
    id: string;
    type: string;
    serviceEndpoint: string;
}
interface GQLLinkedResource {
    id: string;
    type: string;
    description: string;
    mediaType: string;
    serviceEndpoint: string;
    proof: string;
    encrypted: string;
    right: string;
}
interface EntityNode {
    id: string;
    type: string;
    startDate?: string;
    endDate?: string;
    status: number;
    relayerNode: string;
    credentials?: string[];
    entityVerified: boolean;
    metadata: any;
    accounts: any;
    externalId?: string;
    owner?: string;
    context: any;
    controller: string[];
    verificationMethod: any;
    service: Service[];
    authentication: string[];
    assertionMethod: string[];
    keyAgreement: string[];
    capabilityInvocation: string[];
    capabilityDelegation: string[];
    linkedResource: LinkedResource[];
    linkedClaim: any;
    accordedRight: any;
    linkedEntity: any;
    alsoKnownAs: string;
    settings: any;
    profile?: {
        name?: string;
        [key: string]: any;
    };
    iidById: {
        id: string;
        linkedResource: GQLLinkedResource[];
    };
}
interface EntityResponse$1 {
    id: string;
    context: string;
    relayerNode: string;
    controller: string;
    type: string;
    startDate: string;
    endDate: string;
    metadata: string;
    linkedResource: LinkedResource[];
    settings: Record<string, LinkedResource>;
    service: Service[];
    externalId: string;
}
interface Asset {
    did: string;
    alsoKnownAs: string;
    name: string;
    icon: string;
    issuer: string;
    owned: boolean;
    price: number;
    available: boolean;
    currency: string;
    description?: string;
}
interface POD {
    did: string;
    name: string;
    icon: string;
    members: number;
    isMember: boolean;
    totalProposals: number;
    startDate: string;
    endDate: string;
    description?: string;
}
interface Request {
    did: string;
    name: string;
    icon: string;
    budget: number;
    isMember: boolean;
    currency: string;
    brand: string;
    totalApplications: number;
    description?: string;
}
interface Project {
    did: string;
    name: string;
    icon: string;
    description?: string;
}
interface Dao {
    did: string;
    name: string;
    icon: string;
    description?: string;
    type?: 'dao' | 'pod' | 'group';
    isOwner?: boolean;
    isController?: boolean;
    isMember?: boolean;
}
interface Balance {
    denom: string;
    tokenName: string;
    chainCount: number;
    tokenImage: string;
    amount: number;
    usdAmount: number;
    isCoin: boolean;
    isShare: boolean;
    isCredit: boolean;
}
interface Oracle {
    did: string;
    name: string;
    icon: string;
    isActive: boolean;
    isInvited: boolean;
    minPoints: number;
    maxPoints: number;
    currency: string;
    brand: string;
    flowsAmount: number;
    description?: string;
}
interface Proposal {
    did: string;
    name: string;
    icon: string;
    description: string;
    isVotedOn: boolean;
    vote: string | null;
    status: string;
}
interface Member {
    did: string;
    username: string;
    address: string;
    icon: string;
    percentage: string;
    role: string;
    description?: string;
}
interface Validator {
    did: string;
    name: string;
    description: string;
    icon: string;
    amount: number;
    currency: string;
    commission: number;
    isStaked: boolean;
    isBonding: boolean;
    isActive: boolean;
}
interface Investment {
    did: string;
    name: string;
    icon: string;
    brand: string;
    isSubscribed: boolean;
    isOpen: boolean;
    currency: string;
    currentAmount: number;
    maxAmount: number;
    status: string;
    price: number;
    description?: string;
}
interface Collection {
    did: string;
    name: string;
    brand: string;
    icon: string;
    price: number;
    currency: string;
    totalAssets: number;
    description?: string;
}
interface TransactionByHash {
    code: number;
    fee: {
        payer: string;
        amount: Array<{
            denom: string;
            amount: string;
        }>;
        granter: string;
        gasLimit: {
            low: number;
            high: number;
            unsigned: boolean;
        };
    };
    hash: string;
    height: number;
    memo: string;
    time: string;
}
interface Transaction {
    id: number;
    transactionHash: string;
    typeUrl: string;
    memo: string;
    time: string;
    from: string;
    to: string | null;
    denoms: string[];
    tokenNames: string[];
    value: Record<string, any>;
    transactionByTransactionHash?: TransactionByHash;
    description?: string;
}
interface DeedSubscription {
    did: string;
    subscriberAddress: string;
    subscriberDid?: string;
    subscriberName?: string;
    subscriberImage?: string;
    subscriptionDate: string;
    status: 'active' | 'inactive' | 'pending';
    metadata?: Record<string, any>;
    actionSections?: SelectionActionSection[];
}
type IAssetsListItem = {
    symbol: string;
    description: string;
    display: string;
    entityId: string;
    assetType: string;
    coinMinimalDenom?: string;
    base: string;
    denomUnits: {
        denom: string;
        exponent: number;
        aliases: string[];
    }[];
    logoURIs: {
        png: string;
        svg: string;
        zlottie: string;
    };
    isStakeCurrency: string;
    isFeeCurrency: string;
    isBondToken: string;
    coingeckoId?: string;
    contractAddress?: string;
};
interface Bid {
    id: string;
    did: string;
    collection: string;
    type: 'bid';
    address: string;
    data: string;
    role: string;
    created: string;
}
interface SubmitBidParams {
    collectionId: string;
    role: EAAgentRoles;
    surveyAnswers: any;
}
interface QueryBidsParams {
    collectionId: string;
    pagination?: {
        nextPageToken?: string;
    };
}
interface QueryBidsByDidParams {
    collectionId: string;
    did: string;
}
interface ApproveBidParams {
    bidId: string;
    collectionId: string;
    did: string;
}
interface RejectBidParams {
    bidId: string;
    collectionId: string;
    did: string;
    reason: string;
}
interface BidResponse {
    success: boolean;
    bidId: string;
}
interface QueryBidsResponse {
    data: Bid[];
    nextPageToken?: string;
}
declare enum EAAgentRoles {
    owners = "PO",
    evaluators = "EA",
    serviceProviders = "SA",
    investors = "IA"
}
declare enum AgentRole {
    Owner = "PO",// Collection Controller
    Evaluator = "EA",// Evaluator
    ServiceProvider = "SA",// Contributor
    Investor = "IA"
}
type CheckUserRoleParams = {
    /** Address to check role for */
    userAddress: string;
    /** Admin account address of the entity */
    adminAddress: string;
    /** Deed DID */
    deedDid: string;
    /** Claim collection IDs to check roles for */
    collectionIds: string[];
};
type ClaimCollectionRole = {
    collectionId: string;
    role: AgentRole;
};
type ClaimCollection = {
    id: string;
    name: string;
    description: string;
    entity: string;
    protocol: EntityNode | null;
    admin: string;
};
type ClaimCollectionResponse = {
    adminAddress: string;
    collections: ClaimCollection[];
};
type Claim = {
    claimId: string;
    collectionId: string;
    agentDid: string;
    agentAddress: string;
    submissionDate: string;
    paymentsStatus: {
        approval: string;
        rejection: string;
        evaluation: string;
        submission: string;
    };
    schemaType: string | null;
    approved?: boolean;
    pending?: boolean;
    rejected?: boolean;
    disputed?: boolean;
};
interface GetClaimsPerCollectionIdParams {
    collectionId: string;
}
interface GetClaimsPerUserAddressParams {
    collectionId: string;
    userAddress: string;
}
interface FAQItem {
    question: string;
    answer: string;
}
interface ContactInfo {
    email: string;
    location: string;
    socialLinks: string[];
    website: string;
}
interface Relationships {
    funders?: string[];
    memberOf?: string[];
    partners?: string[];
}
interface LogoUrl {
    alt: string;
    url: string;
}
interface AdditionalProperties {
    content_hashes?: Record<string, string>;
    content_summaries?: Record<string, string>;
    fetch_errors?: Array<{
        error: string;
        url: string;
    }>;
    last_fetch_date?: string;
}
interface Coordinates {
    type: string;
    coordinates: [number, number];
}
interface DomainCard {
    additional_properties?: AdditionalProperties;
    address?: string;
    alternate_names?: string[];
    area_served?: string;
    categories?: string[];
    contact?: ContactInfo;
    coordinates?: Coordinates;
    credential_type?: string[];
    description?: string;
    entity_type?: string[];
    faq?: FAQItem[];
    id: string;
    image_urls?: Array<Record<string, any>>;
    indexed_at?: string;
    issuer?: string;
    keywords?: string[];
    knows_about?: string[];
    location?: string;
    logo_url?: LogoUrl;
    name: string;
    overview?: string;
    relationships?: Relationships;
    same_as?: string[];
    schema_id?: string;
    summary?: string;
    updated_at?: string;
    url?: string;
    valid_from?: string;
}
interface AssetDetails extends Asset {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface CollectionDetails extends Collection {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface TransactionDetails extends Transaction {
    image: string;
    actionSections: SelectionActionSection[];
}
interface InvestmentDetails extends Investment {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface OracleDetails extends Oracle {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface PODDetails extends POD {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface ProposalDetails extends Proposal {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface RequestDetails extends Request {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface MemberDetails extends Member {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface ValidatorDetails extends Validator {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface LinkedResourceDetails extends LinkedResource {
    image: string;
    actionSections: SelectionActionSection[];
}
interface ProjectDetails extends Project {
    type: string;
    image: string;
    actionSections: SelectionActionSection[];
}
interface DaoDetails extends Dao {
    image: string;
    actionSections: SelectionActionSection[];
}
interface BalanceDetails extends Balance {
    image: string;
    actionSections: SelectionActionSection[];
}
interface DeedSubscriptionDetails extends DeedSubscription {
    image: string;
    actionSections: SelectionActionSection[];
}
interface ClaimDetails extends Claim {
    image: string;
    actionSections: SelectionActionSection[];
}
interface DAOGroup {
    id: string;
    name: string;
    coreAddress: string;
}
interface BlockRequirements {
    proposal?: {
        coreAddress: string;
    };
}
interface UnlMapConfig {
    apiKey: string;
    vpmId: string;
}
/**
 * UDID outcome values matching EvaluationStatus enum
 * PENDING = 0, APPROVED = 1, REJECTED = 2, DISPUTED = 3, INVALIDATED = 4, UNRECOGNIZED = -1
 */
type UdidOutcome = 0 | 1 | 2 | 3 | 4 | -1;
/**
 * Granular step result item for UDID
 */
interface UdidResultItem {
    /** Unique identifier for this result item */
    id: string;
    /** Type of check/step */
    kind: 'compute' | 'fetch' | 'check' | 'validate';
    /** Whether this step passed */
    success: boolean;
    /** Score or value (optional) */
    score?: number;
    /** Output data from this step */
    outputs?: Record<string, any>;
    /** Human-readable message */
    message?: string;
    /** Error message if failed */
    error?: string;
}
/**
 * Signed UDID structure
 */
interface SignedUdid {
    /** Unique identifier for this UDID */
    id: string;
    /** The unsigned UDID payload */
    payload: {
        /** Subject of the evaluation (claim CID) */
        sub: string;
        /** Issuer DID (evaluator) */
        iss: string;
        /** Audience/context (deed DID) */
        aud: string;
        /** Issued at timestamp */
        iat: number;
        /** Expiration timestamp (optional) */
        exp?: number;
        /** Action/capability context */
        act: {
            capabilityCid: string;
            capabilitySchema: string;
            rubricAuthority: string;
            rubricId: string;
            environment: string;
            evaluatorVersion?: string;
        };
        /** Result data */
        res: {
            outcome: number;
            tag: string;
            patch?: Record<string, any>;
            traceCid?: string;
            traceHash?: string;
            items?: UdidResultItem[];
            resultSchema?: string;
        };
        /** Metadata */
        meta: {
            collectionId: string;
            timestamp: string;
        };
    };
    /** Signature of the payload */
    signature: string;
    /** Verification method used for signing */
    verificationMethod: string;
}
/**
 * Parameters for creating a UDID
 */
interface CreateUdidParams {
    /** CID of the claim being evaluated */
    claimCid: string;
    /** DID of the Deed/Context where this result applies */
    deedDid: string;
    /** Collection ID for the claim */
    collectionId: string;
    /** CID of the UCAN/capability that authorized this evaluation */
    capabilityCid: string;
    /** Schema of the capability (default: "ixo-protocol-v1") */
    capabilitySchema?: string;
    /** DID of the rubric authority (usually the Deed DID) */
    rubricAuthority: string;
    /** Version/ID of the rubric used */
    rubricId: string;
    /** Environment (default: "production") */
    environment?: 'production' | 'simulation' | 'testnet';
    /** Version of the evaluator (optional) */
    evaluatorVersion?: string;
    /** Outcome of the evaluation matching EvaluationStatus enum (0=PENDING, 1=APPROVED, 2=REJECTED, 3=DISPUTED, 4=INVALIDATED, -1=UNRECOGNIZED) */
    outcome: UdidOutcome | number;
    /** Human-readable tag for the outcome */
    tag: string;
    /** State patch to apply to Digital Twin (optional) */
    patch?: Record<string, any>;
    /** CID of the trace/reasoning logs (optional) */
    traceCid?: string;
    /** Hash of the trace for integrity (optional) */
    traceHash?: string;
    /** Granular step results (optional) */
    items?: UdidResultItem[];
    /** Schema for result validation (optional) */
    resultSchema?: string;
    /** Type of issuer: entity or user */
    issuerType: 'entity' | 'user';
    /** Entity room ID (required if issuerType is "entity") */
    entityRoomId?: string;
    /** PIN for decrypting signing key */
    pin: string;
    /** Expiration time in seconds from now (optional) */
    expiresInSeconds?: number;
}
/**
 * Response from creating a UDID
 */
interface CreateUdidResponse {
    /** Whether the UDID was created successfully */
    success: boolean;
    /** The signed UDID */
    udid: SignedUdid;
    /** CID of the stored UDID in public storage (IPFS/Matrix) */
    cid: string;
    /** URL to fetch the UDID from public storage */
    url: string;
    /** Transaction hash if submitted on-chain */
    transactionHash?: string;
}
interface VoteParams {
    proposalId: number;
    rationale?: string;
    vote: Vote;
    proposalContractAddress: string;
}
interface CreateProposalParams {
    preProposalContractAddress: string;
    title: string;
    description: string;
    actions?: ProposalAction[];
    coreAddress?: string;
    groupContractAddress?: string;
}
interface EmailNotificationParams {
    channel: 'email';
    to: string[];
    cc?: string[];
    bcc?: string[];
    subject: string;
    body: string;
    bodyType?: 'text' | 'html';
    from?: string;
    replyTo?: string;
}
interface SmsNotificationParams {
    channel: 'sms';
    to: string[];
    body: string;
}
interface WhatsAppNotificationParams {
    channel: 'whatsapp';
    to: string[];
    body: string;
    templateId?: string;
    templateVariables?: Record<string, string>;
}
type NotificationParams = EmailNotificationParams | SmsNotificationParams | WhatsAppNotificationParams;
interface NotificationResponse {
    messageId: string;
    status: 'accepted' | 'rejected';
    timestamp: string;
}
interface WorkspacePage {
    id: string;
    type: string;
    description: string;
    serviceEndpoint: string;
    mediaType: string;
}
interface BlocknoteHandlers {
    getVote: (proposalContractAddress: string, proposalId: string, userAddress: string) => Promise<VoteResponse>;
    getProposal: (proposalContractAddress: string, proposalId: string) => Promise<ProposalResponse>;
    getCurrentUser: () => User;
    getRoomMembers: (roomId: string, mx: MatrixClient) => Promise<AwarenessDocActor[]>;
    getMatrixInfoPerDid: (did: string) => Promise<IUserMatrixProfile>;
    getDaoGroupsIds: () => Promise<string[] | undefined>;
    getDAOGroups: () => Promise<DAOGroup[]>;
    getRelayerDid: () => string | undefined;
    getEntityDid: () => string | undefined;
    getAdminAccountAddress: (deedDid: string) => Promise<string>;
    getOnlyClaimCollections: (deedDid: string) => Promise<ClaimCollection[]>;
    vote: ({ proposalId, rationale, vote, proposalContractAddress }: VoteParams) => Promise<void>;
    createProposal: (params: CreateProposalParams) => Promise<string>;
    getEntity: (did: string) => Promise<EntityResponse$1>;
    getDomainCard: () => Promise<DomainCard>;
    askCompanion: (prompt: string) => Promise<void>;
    getCryptoAssets: () => Promise<IAssetsListItem[]>;
    getAssets: (collectionDid: string, page: number, ownerAddress?: string) => Promise<{
        data: Asset[];
        totalCount: number;
    }>;
    getDeedSubscriptions: (relayerDid: string, page: number) => Promise<{
        data: DeedSubscription[];
        totalCount: number;
    }>;
    getCollections: (relayerDid: string, page: number) => Promise<{
        data: Collection[];
        totalCount: number;
    }>;
    getTransactions: (address: string, page: number) => Promise<{
        data: Transaction[];
        totalCount: number;
    }>;
    getInvestments: (relayerDid: string, page: number) => Promise<{
        data: Investment[];
        totalCount: number;
    }>;
    getOracles: (relayerDid: string, page: number) => Promise<{
        data: Oracle[];
        totalCount: number;
    }>;
    getPODs: (relayerDid: string, page: number, role?: string) => Promise<{
        data: POD[];
        totalCount: number;
    }>;
    getProposals: (relayerDid: string, page: number) => Promise<{
        data: Proposal[];
        totalCount: number;
    }>;
    getRequests: (relayerDid: string, page: number) => Promise<{
        data: Request[];
        totalCount: number;
    }>;
    getDaos: (relayerDid: string, page: number, role?: string) => Promise<{
        data: Dao[];
        totalCount: number;
    }>;
    getDaoGroups?: (relayerDid: string, page: number, role?: string) => Promise<{
        data: Dao[];
        totalCount: number;
    }>;
    getProjects: (relayerDid: string, page: number) => Promise<{
        data: Project[];
        totalCount: number;
    }>;
    getMembers: (address: string, groupCoreAddress: string, withBalance: boolean, page: number) => Promise<{
        data: Member[];
        totalCount: number;
    }>;
    getDaoMembers: (address: string, groupIds: string[], withBalance: boolean, page: number) => Promise<{
        data: Member[];
        totalCount: number;
    }>;
    getValidators: (relayerDid: string, page: number) => Promise<{
        data: Validator[];
        totalCount: number;
    }>;
    executeProposal: (params: {
        proposalId: number;
        proposalContractAddress: string;
    }) => Promise<void>;
    getProposalContractAddress: (params: {
        coreAddress: string;
    }) => Promise<{
        proposalContractAddress: string;
    }>;
    getPreProposalContractAddress: (params: {
        coreAddress: string;
    }) => Promise<{
        preProposalContractAddress: string;
    }>;
    getGroupContractAddress: (params: {
        coreAddress: string;
    }) => Promise<{
        groupContractAddress: string;
    }>;
    getBalances: (address: string) => Promise<{
        data: Balance[];
    }>;
    sendNotification: (params: NotificationParams) => Promise<NotificationResponse>;
    getAssetDetails?: (id: string) => Promise<AssetDetails>;
    getCollectionDetails?: (id: string) => Promise<CollectionDetails>;
    getTransactionDetails?: (id: string) => Promise<TransactionDetails>;
    getInvestmentDetails?: (id: string) => Promise<InvestmentDetails>;
    getOracleDetails?: (id: string) => Promise<OracleDetails>;
    getPODDetails?: (id: string) => Promise<PODDetails>;
    getProposalDetails?: (id: string) => Promise<ProposalDetails>;
    getRequestDetails?: (id: string) => Promise<RequestDetails>;
    getMemberDetails?: (id: string) => Promise<MemberDetails>;
    getValidatorDetails?: (id: string) => Promise<ValidatorDetails>;
    getLinkedResourceDetails?: (id: string) => Promise<LinkedResourceDetails>;
    getDaoMemberDetails?: (id: string) => Promise<MemberDetails>;
    getProjectDetails?: (id: string) => Promise<ProjectDetails>;
    getDaoDetails?: (id: string) => Promise<DaoDetails>;
    getBalanceDetails?: (id: string) => Promise<BalanceDetails>;
    getDeedSubscriptionDetails?: (id: string) => Promise<DeedSubscriptionDetails>;
    getClaimDetails?: (id: string) => Promise<ClaimDetails>;
    getDeedSurveyTemplate: (deedDid: string, claimCollectionId?: string) => Promise<{
        surveyTemplate: any;
        claimCollectionId: string;
    } | null>;
    submitClaim: (params: {
        surveyData: any;
        deedDid: string;
        collectionId: string;
        adminAddress: string;
        pin: string;
    }) => Promise<{
        transactionHash: string;
        claimId: string;
    }>;
    requestPin: (config?: {
        title?: string;
        description?: string;
        submitText?: string;
    }) => Promise<string>;
    getClaimCollections: (deedDid: string) => Promise<ClaimCollectionResponse>;
    getClaimsPerCollectionId: (params: GetClaimsPerCollectionIdParams) => Promise<Claim[]>;
    getClaimsPerUserAddress: (params: GetClaimsPerUserAddressParams) => Promise<Claim[]>;
    getClaimData: (collectionId: string, claimId: string) => Promise<any>;
    fetchClaimMedia?: (url: string) => Promise<Blob>;
    evaluateClaim: (granteeAddress: string, did: string, payload: {
        claimId: string;
        collectionId: string;
        adminAddress: string;
        status?: number;
        verificationProof: string;
        amount?: Coin | 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, claimCollectionId?: string) => Promise<{
        surveyTemplate: any;
    } | null>;
    getBidEvaluatorSurveyTemplate: (deedId: string, claimCollectionId?: string) => Promise<{
        surveyTemplate: any;
    } | null>;
    approveServiceAgentApplication: (params: {
        adminAddress: string;
        collectionId: string;
        agentQuota: number;
        deedDid: string;
        currentUserAddress: string;
    }) => Promise<void>;
    approveEvaluatorApplication: (params: {
        adminAddress: string;
        collectionId: string;
        deedDid: string;
        evaluatorAddress: string;
        agentQuota?: number;
        claimIds?: string[];
        maxAmounts?: Coin[];
    }) => Promise<void>;
    publicFileUpload: (file: File) => Promise<{
        encrypted: string;
        cid: string;
        proof: string;
        serviceEndpoint: string;
        url: string;
        mxc: string;
    }>;
    /**
     * Check if entity has signing key set up
     */
    checkEntitySigningSetup?: (entityDid: string) => Promise<{
        hasSigningKey: boolean;
        keyId?: string;
    }>;
    /**
     * Set up entity signing (generates mnemonic, adds verification method)
     * Requires wallet signature
     */
    setupEntitySigning?: (params: {
        entityDid: string;
        entityRoomId: string;
        pin: string;
    }) => Promise<{
        transactionHash: string;
        keyId: string;
    }>;
    /**
     * Check if current user has signing key set up
     */
    checkUserSigningSetup?: () => Promise<{
        hasSigningKey: boolean;
        keyId?: string;
    }>;
    /**
     * Sign a capability delegation
     * @deprecated Use createDelegation instead for @ixo/ucan CAR format
     */
    signCapability?: (params: {
        /** DID of issuer (entity or user) */
        issuerDid: string;
        /** Whether signing as entity or user */
        issuerType: 'entity' | 'user';
        /** Entity room ID (required if issuerType is 'entity') */
        entityRoomId?: string;
        /** DID of recipient */
        audience: string;
        /** Capabilities to grant */
        capabilities: Array<{
            can: string;
            with: string;
            nb?: Record<string, any>;
        }>;
        /** IDs of parent capabilities (proofs) */
        proofs?: string[];
        /** Expiration timestamp */
        expiration?: number;
        /** PIN to decrypt signing mnemonic */
        pin: string;
    }) => Promise<{
        id: string;
        raw: string;
        signature: string;
    }>;
    /**
     * Verify a capability signature against issuer's DID document
     * @deprecated Use validateInvocation instead
     */
    verifyCapabilitySignature?: (params: {
        /** Raw capability JSON */
        capabilityRaw: string;
        /** Expected issuer DID */
        issuerDid: string;
    }) => Promise<{
        valid: boolean;
        error?: string;
    }>;
    /**
     * Create a delegation using @ixo/ucan (CAR format)
     */
    createDelegation?: (params: {
        /** DID of issuer */
        issuerDid: string;
        /** Whether signing as entity or user */
        issuerType: 'entity' | 'user';
        /** Entity room ID (required if issuerType is 'entity') */
        entityRoomId?: string;
        /** DID of recipient */
        audience: string;
        /** Capabilities to grant */
        capabilities: Array<{
            can: string;
            with: string;
            nb?: Record<string, unknown>;
        }>;
        /** CIDs of proof delegations */
        proofs?: string[];
        /** Expiration timestamp (milliseconds) */
        expiration?: number;
        /** PIN to decrypt signing mnemonic */
        pin: string;
    }) => Promise<{
        /** Content ID of the delegation */
        cid: string;
        /** Base64-encoded CAR bytes */
        delegation: string;
    }>;
    /**
     * Create an invocation using @ixo/ucan (CAR format)
     */
    createInvocation?: (params: {
        /** DID of invoker */
        invokerDid: string;
        /** Whether signing as entity or user */
        invokerType: 'entity' | 'user';
        /** Entity room ID (required if invokerType is 'entity') */
        entityRoomId?: string;
        /** Capability to invoke */
        capability: {
            can: string;
            with: string;
            nb?: Record<string, unknown>;
        };
        /** CIDs of proof delegations */
        proofs: string[];
        /** Additional facts/context */
        facts?: Record<string, unknown>;
        /** PIN to decrypt signing mnemonic */
        pin: string;
    }) => Promise<{
        /** Content ID of the invocation */
        cid: string;
        /** Base64-encoded CAR bytes */
        invocation: string;
    }>;
    /**
     * Validate an invocation against its proof chain
     */
    validateInvocation?: (params: {
        /** Base64-encoded CAR invocation */
        invocation: string;
        /** Base64-encoded CAR delegations (proofs) */
        delegations: string[];
    }) => Promise<{
        valid: boolean;
        error?: string;
        /** Issuer DID if valid */
        issuer?: string;
        /** Validated capability if valid */
        capability?: {
            can: string;
            with: string;
            nb?: Record<string, unknown>;
        };
    }>;
    /**
     * Parse a delegation from Base64 CAR format
     */
    parseDelegation?: (
    /** Base64-encoded CAR delegation */
    delegation: string) => Promise<{
        cid: string;
        issuer: string;
        audience: string;
        capabilities: Array<{
            can: string;
            with: string;
            nb?: Record<string, unknown>;
        }>;
        expiration?: number;
        proofs: string[];
    }>;
    /**
     * Search for users by name or DID
     */
    searchUsers?: (query: string) => Promise<Array<{
        did: string;
        displayName: string;
        avatarUrl?: string;
        address?: string;
    }>>;
    /**
     * Get registered oracles for an entity
     */
    getRegisteredOracles?: (entityDid: string) => Promise<Array<{
        did: string;
        name: string;
        description?: string;
        capabilities?: string[];
    }>>;
    /**
     * Get entity info including room ID
     */
    getEntityInfo?: (entityDid: string) => Promise<{
        did: string;
        name: string;
        roomId: string;
        adminAddress: string;
        controllerDid: string;
    }>;
    /**
     * Sign a Verifiable Credential using entity or user key.
     * Creates a DataIntegrityProof using eddsa-rdfc-2022 cryptosuite.
     */
    signCredential?: (params: {
        /** DID of issuer (entity or user) */
        issuerDid: string;
        /** Whether signing as entity or user */
        issuerType: 'entity' | 'user';
        /** Entity room ID (required if issuerType is 'entity') */
        entityRoomId?: string;
        /** The unsigned credential to sign */
        credential: {
            '@context': any;
            id: string;
            type: string[];
            issuer: {
                id: string;
            };
            validFrom: string;
            validUntil: string;
            credentialSchema: {
                id: string;
                type: string;
            };
            credentialSubject: any;
        };
        /** PIN to decrypt signing mnemonic */
        pin: string;
    }) => Promise<{
        /** The signed credential with proof attached */
        signedCredential: {
            '@context': any;
            id: string;
            type: string[];
            issuer: {
                id: string;
            };
            validFrom: string;
            validUntil: string;
            credentialSchema: {
                id: string;
                type: string;
            };
            credentialSubject: any;
            proof: {
                type: 'DataIntegrityProof';
                created: string;
                verificationMethod: string;
                cryptosuite: 'eddsa-rdfc-2022';
                proofPurpose: 'assertionMethod';
                proofValue: string;
            };
        };
    }>;
    /**
     * Redirect to entity overview page
     */
    redirectToEntityOverview?: (did: string, type: string) => void;
    /**
     * Create a new domain entity with the provided linked resources.
     * This is called after the domain card credential has been uploaded.
     */
    createDomain?: (params: {
        /** Entity type from survey (e.g., 'dao', 'protocol') */
        entityType: string;
        /** Linked resources to attach to the entity (includes domain card) */
        linkedResource: Array<{
            id: string;
            type: string;
            proof: string;
            right: string;
            encrypted: string;
            mediaType: string;
            description: string;
            serviceEndpoint: string;
        }>;
        /** Linked entities (e.g., governance groups) */
        linkedEntity?: Array<{
            id: string;
            type: string;
            relationship: string;
            service: string;
        }>;
        /** Start date for the entity (from validFrom) */
        startDate?: string;
        /** End date for the entity (from validUntil) */
        endDate?: string;
    }) => Promise<{
        /** The DID of the newly created entity */
        entityDid: string;
        /** Transaction hash */
        transactionHash: string;
    }>;
    /**
     * List available email templates from Mailgun
     */
    listEmailTemplates?: (params: {
        limit?: number;
        page?: string;
    }) => Promise<{
        items: Array<{
            name: string;
            description?: string;
            createdAt: string;
        }>;
        paging?: {
            first: string;
            last: string;
            next?: string;
            previous?: string;
        };
    }>;
    /**
     * Get a specific email template with optional active version content
     */
    getEmailTemplate?: (params: {
        templateName: string;
        active?: boolean;
    }) => Promise<{
        name: string;
        description?: string;
        version?: {
            tag: string;
            template: string;
            engine: string;
            active: boolean;
            createdAt: string;
        };
    }>;
    /**
     * Send an email using a template
     */
    sendEmail?: (params: {
        to: string;
        subject: string;
        template: string;
        templateVersion?: string;
        variables?: Record<string, any>;
        cc?: string;
        bcc?: string;
        replyTo?: string;
    }) => Promise<{
        id: string;
        message: string;
    }>;
    /**
     * Store a verifiable credential in Matrix room state.
     * Used by the credential.store action type.
     */
    storeMatrixCredential?: (params: {
        roomId: string;
        credentialKey: string;
        credential: Record<string, any>;
        cid: string;
    }) => Promise<{
        storedAt: string;
        duplicate: boolean;
    }>;
    /**
     * Get the evaluation template linked resource for a deed
     */
    getEvaluationTemplate?: (deedDid: string) => Promise<{
        surveyTemplate: any;
        claimCollectionId: string;
    } | null>;
    /**
     * Get the rubric linked resource for a deed
     */
    getDeedRubric?: (deedDid: string) => Promise<{
        rubric: any;
        claimCollectionId: string;
    } | null>;
    /**
     * Evaluate a claim using a rubric via the rubric engine
     */
    evaluateWithRubric?: (params: {
        rubric: string;
        claim: Record<string, any>;
    }) => Promise<{
        success: boolean;
        trace?: {
            traceId: string;
            rubricVersion: number;
            rubricName: string | null;
            actor: {
                type: 'ai' | 'human';
                id?: string;
            } | null;
            result: {
                outcome: 'pass' | 'fail' | 'escalated';
                steps: Array<{
                    stepId: string;
                    kind: 'compute' | 'fetch' | 'check';
                    success: boolean;
                    outputs?: Record<string, any>;
                    message?: string;
                    error?: string;
                    duration?: number;
                    timestamp: string;
                }>;
                executionId: string;
                startTime: string;
                endTime: string;
                totalDuration: number;
                escalatedTo?: string;
            };
            claim: Record<string, any>;
        };
        error?: string;
    }>;
    /**
     * Create a Universal Decentralized Identifier (UDID) for an evaluation result
     */
    createUdid?: (params: CreateUdidParams) => Promise<CreateUdidResponse>;
    /**
     * Create a new governance group (categorical, multisig, NFT staking, or token staking).
     * The implementation is provided by the host application.
     */
    createGovernanceGroup?: (params: {
        /** Type of governance group to create */
        groupType: 'categorical' | 'multisig' | 'nftStaking' | 'tokenStaking';
        /** Name of the group */
        name: string;
        /** Optional description */
        description?: string;
        /** Group-type specific configuration from the survey */
        config: Record<string, unknown>;
    }) => Promise<{
        /** The DAO core contract address */
        coreAddress: string;
        /** The voting group contract address */
        groupAddress: string;
        /** Transaction hash */
        transactionHash: string;
    }>;
    /**
     * List entities where a given DID holds a specified role (e.g. 'controller').
     * Used by the POD setup flow to list parent organisations the user can nest under.
     */
    getEntitiesByRole?: (params: {
        /** DID of the actor */
        did: string;
        /** Role to filter by (e.g. 'controller', 'admin') */
        role: string;
    }) => Promise<Array<{
        did: string;
        name?: string;
        /** IXO entity type string, e.g. 'dao/dao', 'dao/pod', 'protocol/deed' */
        type?: string;
        icon?: string;
        description?: string;
    }>>;
    /**
     * List flow templates available for a given blueprint entity.
     * Used by the POD setup flow to let the user select startup flows.
     */
    getFlowTemplates?: (params: {
        /** Entity DID of the blueprint/protocol */
        entityDid: string;
    }) => Promise<Array<{
        did: string;
        name?: string;
        description?: string;
    }>>;
    /**
     * Create a Cosmos governance group from explicit members and decision policy.
     * Used by the POD setup flow after domain entity creation.
     */
    createGroup?: (params: {
        /** The entity DID of the newly created domain (to associate the group) */
        entityDid: string;
        /** Members with roles and voting power */
        members: Array<{
            did: string;
            role: string;
            votingPower: number;
        }>;
        /** Decision policy parameters */
        decisionPolicy: {
            votingPeriod: string;
            quorum: string;
            threshold: string;
            vetoThreshold: string;
            minExecutionDelay: string;
            executor: string;
        };
        /** Optional group name (defaults to entity name) */
        name?: string;
    }) => Promise<{
        /** The group/DAO core contract address */
        groupAddress: string;
        /** Transaction hash */
        transactionHash: string;
    }>;
    /**
     * Navigate to a flow link URL
     * @param url - HTTP URL of the target flow or page
     */
    navigateToFlow?: (url: string) => void;
    /**
     * Get the status of a flow document
     * @param url - HTTP URL of the flow document
     * @returns Flow status with optional completion timestamp
     */
    getFlowStatus?: (url: string) => Promise<{
        status: 'not_started' | 'in_progress' | 'completed';
        completedAt?: string;
    }>;
    /**
     * Get workspace pages from protocol deed entity.
     * The host app automatically determines the network context.
     * @returns Array of workspace pages with type "Page" and mediaType "application/matrix"
     */
    getWorkspacePages?: () => Promise<WorkspacePage[]>;
    /**
     * Create a new signer session for handle-based signing.
     *
     * This allows the editor to request signing operations without receiving
     * raw key material. The host app manages the session lifecycle and key security.
     *
     * @example
     * ```typescript
     * // Create a session-scoped signer for batch operations
     * const session = await handlers.createSignerSession({
     *   did: 'did:ixo:entity:abc123',
     *   didType: 'entity',
     *   entityRoomId: '!room:matrix.ixo.world',
     *   pin: '123456',
     *   scope: 'session',
     *   ttlSeconds: 300
     * });
     *
     * // Use for multiple signatures without re-entering PIN
     * const sig1 = await handlers.signWithSession({ sessionId: session.sessionId, data: '...' });
     * const sig2 = await handlers.signWithSession({ sessionId: session.sessionId, data: '...' });
     *
     * // Release when done
     * await handlers.releaseSignerSession({ sessionId: session.sessionId });
     * ```
     */
    createSignerSession?: (params: {
        /** DID of the signer (entity or user) */
        did: string;
        /** Whether signing as entity or user */
        didType: 'entity' | 'user';
        /** Entity room ID (required if didType is 'entity') */
        entityRoomId?: string;
        /** PIN to decrypt signing mnemonic */
        pin: string;
        /**
         * Session scope:
         * - 'session': Remains valid for multiple sign operations until TTL or explicit release
         * - 'operation': Automatically invalidated after first sign operation
         */
        scope: 'session' | 'operation';
        /**
         * Time-to-live in seconds (only applicable for 'session' scope)
         * Default: 300 (5 minutes), Maximum: 3600 (1 hour)
         */
        ttlSeconds?: number;
    }) => Promise<{
        /** Opaque session identifier */
        sessionId: string;
        /** DID of the signer */
        did: string;
        /** Public key in multibase format (for verification) */
        publicKey: string;
        /** Key ID (verification method ID) */
        keyId: string;
        /** Unix timestamp when the session expires */
        expiresAt: number;
        /** The scope this session was created with */
        scope: 'session' | 'operation';
    }>;
    /**
     * Sign data using an existing signer session.
     *
     * For 'operation' scoped sessions, the session is automatically
     * invalidated after this call succeeds.
     *
     * @throws If session not found, expired, or signing fails
     */
    signWithSession?: (params: {
        /** The session ID returned from createSignerSession */
        sessionId: string;
        /** Data to sign (passed as-is to Ed25519 sign) */
        data: string;
        /** Algorithm hint (currently only Ed25519 supported) */
        algorithm?: 'Ed25519';
    }) => Promise<{
        /** The signature in hex format */
        signature: string;
        /** The algorithm used */
        algorithm: 'Ed25519';
        /** Key ID that was used for signing */
        keyId: string;
    }>;
    /**
     * Release a signer session before it expires.
     *
     * This immediately clears the session from host memory, preventing
     * any further signing operations. Idempotent - safe to call on
     * already-expired or released sessions.
     */
    releaseSignerSession?: (params: {
        /** The session ID to release */
        sessionId: string;
    }) => Promise<{
        /** Whether the session was successfully released */
        released: boolean;
        /** Reason if not released (e.g., already expired) */
        reason?: string;
    }>;
    /**
     * Fetch available skills (capsules) from the skills registry
     */
    getSkills?: () => Promise<{
        capsules: Array<{
            cid: string;
            name: string;
            description: string;
            license: string;
            compatibility: string;
            allowedTools: string;
            metadata: unknown;
            archiveSize: number;
            createdAt: string;
        }>;
        pagination: {
            total: number;
            limit: number;
            offset: number;
            hasMore: boolean;
        };
    }>;
    /**
     * Invoke a named skill with the given payload and return the result.
     */
    invokeSkill?: (skillName: string, payload: Record<string, unknown>) => Promise<unknown>;
}
type DocType = 'template' | 'flow';
/**
 * Visualization renderer type for AG-UI integration.
 * This function is called by visualization blocks to render the actual AG-UI component.
 * @param vizType - The type of visualization (e.g., 'lineChart', 'barChart', 'dataTable', etc.)
 * @param config - The configuration object for the visualization
 * @param preferences - Optional user customizations (e.g., { pageSize: 25 }) persisted to the block
 * @param onPreferencesChange - Optional callback to update preferences (persists via CRDT)
 * @returns React node with the rendered visualization, or null if type is not supported
 */
type VisualizationRenderer = (vizType: string, config: object, preferences?: object, onPreferencesChange?: (prefs: object) => void) => React__default.ReactNode | null;
/**
 * Domain card data structure for rendering domain card previews
 */
interface DomainCardData {
    name?: string;
    summary?: string;
    description?: string;
    entity_type?: string[];
    faq?: Array<{
        question: string;
        answer: string;
    }>;
    logo_url?: {
        url?: string;
        alt?: string;
    };
    image_urls?: Array<{
        url: string;
        alt: string;
    }>;
    keywords?: string[];
    valid_from?: string;
    issuer?: string;
    area_served?: string;
    address?: string;
    coordinates?: {
        type: string;
        coordinates: [number, number];
    };
    contact?: {
        email?: string;
        website?: string;
        location?: string;
        socialLinks?: string[];
    };
    [key: string]: unknown;
}
/**
 * Renderer for domain card previews in the qi/domain.card-preview action.
 * The web app provides this renderer to display domain card data with proper styling.
 */
type DomainCardRenderer = (domainCardData: DomainCardData) => React__default.ReactNode;
/**
 * Dynamic list data returned by the data provider
 */
interface DynamicListData {
    items: any[] | null;
    loading: boolean;
    error: string | null;
}
/**
 * Function type for getting dynamic list data from context
 */
type DynamicListDataProvider = (listId: string) => DynamicListData;
/**
 * Dynamic list column definition (imported from types for context)
 */
interface DynamicListColumn {
    key: string;
    label: string;
    position?: 'topLeft' | 'bottomLeft' | 'topRight' | 'bottomRight';
    type?: 'string' | 'number' | 'date';
    color?: string;
}
/**
 * DataSource for dynamic lists
 */
interface DataSource {
    oracleDid: string;
    oracleName?: string;
    query: string;
    toolName?: string;
    params?: Record<string, any>;
    description?: string;
}
/**
 * Action that can be performed on a dynamic list item
 */
interface DynamicListAction {
    id: string;
    label: string;
    color?: string;
}
/**
 * Panel renderer type for dynamic list selection panel.
 * This function is called when an item is selected in a dynamic list.
 * If provided, renders custom content. If not provided, shows default key-value view.
 * @param item - The selected item data
 * @param columns - Column definitions from the dynamic list
 * @param dataSource - Data source info (oracle, query, etc.)
 * @returns React node with custom panel content, or null to use default
 */
type DynamicListPanelRenderer = (item: any, columns: DynamicListColumn[], dataSource: DataSource | null, panelDescription?: string, actions?: DynamicListAction[], onClose?: () => void) => React__default.ReactNode | null;
interface BlocknoteContextValue {
    editor?: IxoEditorType;
    handlers?: BlocknoteHandlers;
    blockRequirements?: BlockRequirements;
    mapConfig?: UnlMapConfig;
    editable?: boolean;
    docType: DocType;
    /** Current flow schema version (e.g., '0.3', '1.0.0') */
    flowVersion: string;
    sharedProposals: SharedProposalData;
    fetchSharedProposal: (proposalId: string, contractAddress: string, force?: boolean) => Promise<ProposalResponse>;
    invalidateProposal: (proposalId: string) => void;
    subscribeToProposal: (proposalId: string) => ProposalResponse | undefined;
    activeDrawerId: string | null;
    drawerContent: React__default.ReactNode | null;
    openDrawer: (id: string, content: React__default.ReactNode) => void;
    closeDrawer: () => void;
    visualizationRenderer?: VisualizationRenderer;
    getDynamicListData?: DynamicListDataProvider;
    dynamicListPanelRenderer?: DynamicListPanelRenderer;
    domainCardRenderer?: DomainCardRenderer;
    connectedUsers?: Array<{
        clientId: string;
        state: any;
    }>;
    awarenessInstance?: any;
}
declare const BlocknoteProvider: React__default.FC<{
    children: React__default.ReactNode;
    editor?: IxoEditorType;
    handlers?: BlocknoteHandlers;
    blockRequirements?: BlockRequirements;
    editable?: boolean;
    visualizationRenderer?: VisualizationRenderer;
    getDynamicListData?: DynamicListDataProvider;
    dynamicListPanelRenderer?: DynamicListPanelRenderer;
    domainCardRenderer?: DomainCardRenderer;
    mapConfig?: UnlMapConfig;
    connectedUsers?: Array<{
        clientId: string;
        state: any;
    }>;
    awarenessInstance?: any;
}>;
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 skill: {
                readonly default: "";
            };
        };
        readonly content: "none";
    };
    implementation: _blocknote_core.TiptapBlockImplementation<{
        readonly type: "overview";
        readonly propSchema: {
            readonly skill: {
                readonly default: "";
            };
        };
        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 ttlAbsoluteDueDate: {
                readonly default: "";
            };
            readonly ttlFromEnablement: {
                readonly default: "";
            };
            readonly ttlFromCommitment: {
                readonly default: "";
            };
            readonly skill: {
                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 ttlAbsoluteDueDate: {
                readonly default: "";
            };
            readonly ttlFromEnablement: {
                readonly default: "";
            };
            readonly ttlFromCommitment: {
                readonly default: "";
            };
            readonly skill: {
                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 ttlAbsoluteDueDate: {
                readonly default: "";
            };
            readonly ttlFromEnablement: {
                readonly default: "";
            };
            readonly ttlFromCommitment: {
                readonly default: "";
            };
            readonly assignment: {
                readonly default: string;
            };
            readonly commitment: {
                readonly default: string;
            };
            readonly skill: {
                readonly default: "";
            };
        };
        readonly content: "none";
    };
    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 ttlAbsoluteDueDate: {
                readonly default: "";
            };
            readonly ttlFromEnablement: {
                readonly default: "";
            };
            readonly ttlFromCommitment: {
                readonly default: "";
            };
            readonly assignment: {
                readonly default: string;
            };
            readonly commitment: {
                readonly default: string;
            };
            readonly skill: {
                readonly default: "";
            };
        };
        readonly content: "none";
    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
};

type ApiRequestBlockProps = IxoBlockProps;
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
type KeyValuePair = {
    key: string;
    value: string;
};

/**
 * 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>;
    connectedUsers: Array<{
        clientId: string;
        state: any;
    }>;
    awarenessInstance: any;
};

/** Position info passed to drop callback */
interface DropPosition {
    blockId: string;
    placement: 'before' | 'after';
    index: number;
}
interface ExternalDropZoneProps {
    /** Editor instance to get block positions from */
    editor: any;
    /** Callback when external data is dropped or placed - position only, caller handles data */
    onDrop: (position: DropPosition) => void;
    /** MIME type to accept (default: 'application/x-artifact') */
    acceptedType?: string;
    /** Drop indicator element to show (provided by caller, already has data) */
    dropIndicator?: React__default.ReactNode;
    /** Whether placement mode is active (click-to-place) */
    isPlacementMode?: boolean;
    /** Callback when placement mode should be canceled */
    onPlacementCancel?: () => void;
    /** Children (the editor content) */
    children: React__default.ReactNode;
}
declare const ExternalDropZone: React__default.FC<ExternalDropZoneProps>;

interface IxoEditorProps {
    editor: IxoEditorType | undefined;
    editable?: boolean;
    className?: string;
    onChange?: () => void;
    onSelectionChange?: () => void;
    children?: React__default.ReactNode;
    mantineTheme?: any;
    handlers?: BlocknoteHandlers;
    blockRequirements?: BlockRequirements;
    mapConfig?: UnlMapConfig;
    isPanelVisible?: boolean;
    coverImageUrl?: string;
    logoUrl?: string;
    visualizationRenderer?: (vizType: string, config: object) => React__default.ReactNode;
    getDynamicListData?: DynamicListDataProvider;
    dynamicListPanelRenderer?: DynamicListPanelRenderer;
    domainCardRenderer?: DomainCardRenderer;
    /** Callback when external content is dropped into the editor (receives position only) */
    onExternalDrop?: (position: DropPosition) => void;
    /** MIME type to accept for external drops (default: 'application/x-artifact') */
    externalDropType?: string;
    /** Drop indicator element to show during drag (caller provides with data already populated) */
    dropIndicator?: React__default.ReactNode;
    /** Whether placement mode is active (click-to-place) */
    isPlacementMode?: boolean;
    /** Callback when placement mode should be canceled */
    onPlacementCancel?: () => void;
    /** Connected users from awareness (for block presence) */
    connectedUsers?: Array<{
        clientId: string;
        state: any;
    }>;
    /** Yjs awareness instance (for block presence) */
    awarenessInstance?: any;
}
/**
 * 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, visualizationRenderer, getDynamicListData, dynamicListPanelRenderer, domainCardRenderer, onExternalDrop, externalDropType, dropIndicator, isPlacementMode, onPlacementCancel, mapConfig, connectedUsers, awarenessInstance, }: IxoEditorProps): React__default.ReactElement | null;

interface CoverImageProps {
    coverImageUrl?: string;
    logoUrl?: string;
}
declare function CoverImage({ coverImageUrl, logoUrl }: CoverImageProps): React__default.ReactElement | null;

/** @deprecated The activation gating fields were removed; this type is kept
 *  empty for any external imports during the transition. */
type AuthorizationTabState = Record<string, never>;
interface AuthorizationTabProps extends IxoBlockProps {
    /** Flow URI for capability scoping */
    flowUri?: string;
    /** Entity DID that owns this flow */
    entityDid?: string;
    /** Callback to open flow permissions panel */
    onOpenFlowPermissions?: () => void;
}
declare const AuthorizationTab: React__default.FC<AuthorizationTabProps>;

type EvaluationTabState = {
    linkedClaimCollectionId: string;
};
interface EvaluationTabProps extends IxoBlockProps {
}
declare const EvaluationTab: React__default.FC<EvaluationTabProps>;

interface EntitySigningSetupProps {
    opened: boolean;
    onClose: () => void;
    entityDid: string;
    entityName?: string;
    onSetup: (pin: string) => Promise<{
        success: boolean;
        error?: string;
    }>;
}
declare const EntitySigningSetup: React__default.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__default.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__default.FC<GrantPermissionModalProps>;

interface BlockPresenceUser {
    clientId: string;
    name: string;
    color: string;
    avatar?: string;
}
/**
 * Hook that returns the list of users currently active on a specific block.
 * Subscribes directly to awareness changes for reliable updates.
 * @param blockId - The block ID to check presence for
 * @param options.includeSelf - If true, includes the local user in the results (default: false)
 */
declare function useBlockPresence(blockId: string | undefined, options?: {
    includeSelf?: boolean;
}): BlockPresenceUser[];

/**
 * Hook that tracks when a user interacts with a block and updates awareness state.
 * Returns event handlers (onPointerDown) to attach to block containers.
 *
 * For custom (non-editable) blocks: attach the returned onPointerDown to the container.
 * For text blocks: use editor-level onSelectionChange instead.
 */
declare function useTrackBlockFocus(blockId: string | undefined, editor: IxoEditorType | undefined): {
    onPointerDown: () => void;
};

/**
 * 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 { getEntity as $, AuthorizationTab as A, type BlockPresenceUser as B, CoverImage as C, type VoteResponse as D, EvaluationTab as E, FlowPermissionsPanel as F, GrantPermissionModal as G, type HttpMethod as H, IxoEditor as I, type VoteInfo as J, type KeyValuePair as K, ListBlockSpec as L, type Vote as M, type Addr as N, OverviewBlock as O, ProposalBlockSpec as P, type Uint128 as Q, type Expiration as R, StakeType as S, type Timestamp as T, type User as U, ValidatorActionType as V, type Status as W, type Threshold as X, type Votes as Y, type CosmosMsgForEmpty as Z, type ProposalAction as _, useCreateCollaborativeIxoEditor as a, type Entity as a0, type EntityResponse as a1, type EntityVariables as a2, GraphQLClient as a3, ixoGraphQLClient as a4, type GraphQLResponse as a5, type GraphQLRequest as a6, ExternalDropZone as a7, type DropPosition as a8, type VisualizationRenderer as a9, type DynamicListData as aa, type DynamicListDataProvider as ab, type DynamicListPanelRenderer as ac, type DomainCardRenderer as ad, type DomainCardData as ae, type IxoEditorProps as b, type CoverImageProps as c, type AuthorizationTabState as d, type EvaluationTabState as e, EntitySigningSetup as f, CheckboxBlockSpec as g, ApiRequestBlockSpec as h, type CheckboxBlockProps as i, type ListBlockSettings as j, type ListBlockProps as k, type OverviewBlockProps as l, type ProposalBlockProps as m, type ApiRequestBlockProps as n, useBlockPresence as o, useTrackBlockFocus as p, BlocknoteProvider as q, useBlocknoteContext as r, useBlocknoteHandlers as s, AuthzExecActionTypes as t, useCreateIxoEditor as u, type BlocknoteHandlers as v, type BlocknoteContextValue as w, type BlockRequirements as x, type ProposalResponse as y, type SingleChoiceProposal as z };
