@ixo/editor 1.1.3 → 1.2.0

package/dist/index.d.ts

@@ -0,0 +1,1435 @@
+import * as _blocknote_core from '@blocknote/core';
+import { BlockSchemaFromSpecs, InlineContentSchema, StyleSchema, BlockNoteEditor, PartialBlock } from '@blocknote/core';
+export { Block, BlockNoteEditor, BlockNoteSchema, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from '@blocknote/core';
+import { MatrixClient } from 'matrix-js-sdk';
+import { Map, Array as Array$1, Text, Doc } from 'yjs';
+import React from 'react';
+
+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;
+
+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 {
+    address: string;
+    weight: number;
+}
+interface BaseProposalAction {
+    type: ProposalActionType;
+}
+interface SpendData {
+    to: string;
+    denom: string;
+    amount: string;
+}
+interface ManageMembersData {
+    add: Member[];
+    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 {
+    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[];
+        to_address: string;
+    };
+} | {
+    burn: {
+        amount: Coin[];
+    };
+};
+type StakingMsg = {
+    delegate: {
+        amount: Coin;
+        validator: string;
+    };
+} | {
+    undelegate: {
+        amount: Coin;
+        validator: string;
+    };
+} | {
+    redelegate: {
+        amount: Coin;
+        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;
+        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[];
+        msg: Binary;
+    };
+} | {
+    instantiate: {
+        admin?: string | null;
+        code_id: number;
+        funds: Coin[];
+        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[];
+}
+interface InstantiateData {
+    admin: string;
+    codeId: number;
+    label: string;
+    message: string;
+    funds: Coin[];
+}
+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;
+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;
+}
+interface LinkedResource {
+    id: string;
+    type: string;
+    proof: string;
+    right: string;
+    encrypted: string;
+    mediaType: string;
+    description: string;
+    serviceEndpoint: string;
+}
+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;
+}
+interface Transaction {
+    transactionHash: string;
+    typeUrl: string;
+    memo: string;
+    time: 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;
+}
+interface BlocknoteHandlers {
+    getCurrentDao: () => Promise<{
+        coreAddress: string;
+    }>;
+    getVote: (proposalContractAddress: string, proposalId: string, userAddress: string) => Promise<VoteResponse>;
+    getProposal: (proposalContractAddress: string, proposalId: string) => Promise<ProposalResponse>;
+    getCurrentUser: () => Promise<User>;
+    vote: ({ proposalId, rationale, vote, proposalContractAddress }: VoteParams) => Promise<void>;
+    createProposal: (params: CreateProposalParams) => Promise<string>;
+    executeProposal: (params: {
+        proposalId: number;
+        proposalContractAddress: string;
+    }) => Promise<void>;
+    getProposalContractAddress: (params: {
+        coreAddress: string;
+    }) => Promise<{
+        proposalContractAddress: string;
+    }>;
+    getPreProposalContractAddress: (params: {
+        coreAddress: string;
+    }) => Promise<{
+        preProposalContractAddress: string;
+    }>;
+    getEntity: (did: string) => Promise<EntityResponse$1>;
+    getAssets: (collectionDid: string) => Promise<Asset[]>;
+    getTransactions: (address: string) => Promise<Transaction[]>;
+}
+interface BlocknoteContextValue {
+    editor?: IxoEditorType;
+    handlers?: BlocknoteHandlers;
+    blockRequirements?: BlockRequirements;
+    editable?: boolean;
+    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;
+
+type LinkedResourcesListType = 'linked_resources';
+
+type AssetsListType = 'assets';
+
+type TransactionsListType = 'transactions';
+
+type ListType = LinkedResourcesListType | AssetsListType | TransactionsListType;
+
+interface ListBlockSettings {
+    listType: ListType | null;
+    listConfig: Record<string, any>;
+}
+interface ListBlockProps {
+    block: any;
+    editor: any;
+}
+declare const ListBlock: {
+    config: {
+        readonly type: "list";
+        readonly propSchema: {
+            readonly listType: {
+                readonly default: "";
+            };
+            readonly listConfig: {
+                readonly default: "{}";
+            };
+        };
+        readonly content: "none";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "list";
+        readonly propSchema: {
+            readonly listType: {
+                readonly default: "";
+            };
+            readonly listConfig: {
+                readonly default: "{}";
+            };
+        };
+        readonly content: "none";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+interface OverviewBlockSettings {
+    did: string;
+}
+interface OverviewBlockProps {
+    block: any;
+    editor: any;
+}
+declare const OverviewBlock: {
+    config: {
+        readonly type: "overview";
+        readonly propSchema: {
+            readonly did: {
+                readonly default: "";
+            };
+        };
+        readonly content: "none";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "overview";
+        readonly propSchema: {
+            readonly did: {
+                readonly default: "";
+            };
+        };
+        readonly content: "none";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+declare const ProposalVoteBlockSpec: {
+    config: {
+        readonly type: "proposalVote";
+        readonly propSchema: {
+            readonly dependsOn: {
+                readonly default: string;
+            };
+            readonly proposalBlockId: {
+                readonly default: "";
+            };
+            readonly hasDependencies: {
+                readonly default: true;
+            };
+            readonly dependencies: {
+                readonly default: "";
+            };
+            readonly title: {
+                readonly default: "";
+            };
+            readonly subtitle: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "checklist";
+            };
+            readonly status: {
+                readonly default: "open";
+            };
+            readonly daysLeft: {
+                readonly default: 0;
+            };
+            readonly proposalContractAddress: {
+                readonly default: "";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "none";
+    };
+    implementation: _blocknote_core.TiptapBlockImplementation<{
+        readonly type: "proposalVote";
+        readonly propSchema: {
+            readonly dependsOn: {
+                readonly default: string;
+            };
+            readonly proposalBlockId: {
+                readonly default: "";
+            };
+            readonly hasDependencies: {
+                readonly default: true;
+            };
+            readonly dependencies: {
+                readonly default: "";
+            };
+            readonly title: {
+                readonly default: "";
+            };
+            readonly subtitle: {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly default: "checklist";
+            };
+            readonly status: {
+                readonly default: "open";
+            };
+            readonly daysLeft: {
+                readonly default: 0;
+            };
+            readonly proposalContractAddress: {
+                readonly default: "";
+            };
+            readonly conditions: {
+                readonly default: "";
+            };
+        };
+        readonly content: "none";
+    }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+};
+
+interface ProposalVoteBlockSettings {
+    title: string;
+    subtitle: string;
+    icon: string;
+    status: string;
+    daysLeft: number;
+}
+interface ProposalVoteBlockProps {
+    block: any;
+    editor: any;
+}
+
+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 listConfig: {
+                    readonly default: "{}";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "list";
+            readonly propSchema: {
+                readonly listType: {
+                    readonly default: "";
+                };
+                readonly listConfig: {
+                    readonly default: "{}";
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    overview: {
+        config: {
+            readonly type: "overview";
+            readonly propSchema: {
+                readonly did: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "overview";
+            readonly propSchema: {
+                readonly did: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    proposalVote: {
+        config: {
+            readonly type: "proposalVote";
+            readonly propSchema: {
+                readonly dependsOn: {
+                    readonly default: string;
+                };
+                readonly proposalBlockId: {
+                    readonly default: "";
+                };
+                readonly hasDependencies: {
+                    readonly default: true;
+                };
+                readonly dependencies: {
+                    readonly default: "";
+                };
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly subtitle: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "checklist";
+                };
+                readonly status: {
+                    readonly default: "open";
+                };
+                readonly daysLeft: {
+                    readonly default: 0;
+                };
+                readonly proposalContractAddress: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "proposalVote";
+            readonly propSchema: {
+                readonly dependsOn: {
+                    readonly default: string;
+                };
+                readonly proposalBlockId: {
+                    readonly default: "";
+                };
+                readonly hasDependencies: {
+                    readonly default: true;
+                };
+                readonly dependencies: {
+                    readonly default: "";
+                };
+                readonly title: {
+                    readonly default: "";
+                };
+                readonly subtitle: {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly default: "checklist";
+                };
+                readonly status: {
+                    readonly default: "open";
+                };
+                readonly daysLeft: {
+                    readonly default: 0;
+                };
+                readonly proposalContractAddress: {
+                    readonly default: "";
+                };
+                readonly conditions: {
+                    readonly default: "";
+                };
+            };
+            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 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 content: "none";
+        }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
+    };
+    proposalActions: {
+        config: {
+            readonly type: "proposalActions";
+            readonly propSchema: {
+                readonly dependsOn: {
+                    readonly default: string;
+                };
+                readonly proposalBlockId: {
+                    readonly default: "";
+                };
+                readonly hasDependencies: {
+                    readonly default: true;
+                };
+                readonly dependencies: {
+                    readonly default: "";
+                };
+                readonly actions: {
+                    readonly default: "[]";
+                };
+            };
+            readonly content: "none";
+        };
+        implementation: _blocknote_core.TiptapBlockImplementation<{
+            readonly type: "proposalActions";
+            readonly propSchema: {
+                readonly dependsOn: {
+                    readonly default: string;
+                };
+                readonly proposalBlockId: {
+                    readonly default: "";
+                };
+                readonly hasDependencies: {
+                    readonly default: true;
+                };
+                readonly dependencies: {
+                    readonly default: "";
+                };
+                readonly actions: {
+                    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;
+}[];
+
+/**
+ * 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;
+}
+/**
+ * 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>;
+    /**
+     * Current editor mode (flow, template, readonly)
+     */
+    mode?: EditorMode;
+    /**
+     * Current user information (for collaborative editing)
+     */
+    user?: IxoCollaborativeUser;
+    /**
+     * 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 flow array (structured block storage)
+     * @returns Array of flow blocks
+     */
+    getFlow?: () => any[];
+}
+/**
+ * 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;
+}
+interface IxoCollaborativeUser {
+    name: string;
+    color: string;
+    accessToken: string;
+    address: string;
+    id: string;
+}
+interface IxoCollaborativeEditorOptions extends IxoEditorOptions {
+    user: IxoCollaborativeUser;
+    matrixClient: MatrixClient;
+    roomId: string;
+    /**
+     * 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 IxoEditorProps {
+    editor: IxoEditorType | undefined;
+    editable?: boolean;
+    className?: string;
+    onChange?: () => void;
+    onSelectionChange?: () => void;
+    children?: React.ReactNode;
+    mantineTheme?: any;
+    handlers?: BlocknoteHandlers;
+    blockRequirements?: BlockRequirements;
+}
+/**
+ * IxoEditor component - A customized BlockNote editor for IXO (Mantine UI)
+ */
+declare function IxoEditor({ editor, editable, className, onChange, onSelectionChange, children, mantineTheme, handlers, blockRequirements, }: IxoEditorProps): React.ReactElement | null;
+
+/**
+ * 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 Addr, AuthzExecActionTypes, type BlockRequirements, type BlocknoteContextValue, type BlocknoteHandlers, BlocknoteProvider, type CheckboxBlockProps, CheckboxBlockSpec, type CosmosMsgForEmpty, type Entity, type EntityResponse, type EntityVariables, type Expiration, GraphQLClient, type GraphQLRequest, type GraphQLResponse, type IxoCollaborativeEditorOptions, type IxoCollaborativeUser, IxoEditor, type IxoEditorConfig, type IxoEditorOptions, type IxoEditorProps, type IxoEditorTheme, ListBlock, type ListBlockProps, type ListBlockSettings, OverviewBlock, type OverviewBlockProps, type OverviewBlockSettings, type ProposalAction, type ProposalResponse, ProposalVoteBlockSpec as ProposalVoteBlock, type ProposalVoteBlockProps, type ProposalVoteBlockSettings, type SingleChoiceProposal, StakeType, StakeType as StakeTypeValue, type Status, type Threshold, type Timestamp, type Uint128, type User, ValidatorActionType, type Vote, type VoteInfo, type VoteResponse, type Votes, blockSpecs, getEntity, getExtraSlashMenuItems, ixoGraphQLClient, useBlocknoteContext, useBlocknoteHandlers, useCreateCollaborativeIxoEditor, useCreateIxoEditor };