@trinaryex/sdk 3.9.0 → 4.0.0

package/dist/armature/OrgClient.d.ts

@@ -0,0 +1,372 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { Transaction } from '@mysten/sui/transactions';
+import { IndexerClient } from '../queries';
+import { PackageIds, TransactionExecutor, TxResult, OrderSide } from '../types';
+import { ArmaturePkgs, ProposalConfigPatch } from './actions';
+import { DaoGovernance } from './governance';
+import { BlockCode, CompositeEligibility, OuCapabilities, OuProposalAction, PathCandidate, ResolvedPlan } from './harness';
+import { CapabilityVaultContents, LiveProposal } from './proposals';
+import { ProposalConfigInput } from './transactions';
+import { OrderFlags } from './trading';
+import { OuVaultInfo } from './vault';
+import { TreasuryCoinBalance } from './treasury';
+import { HubDaoVault, Org, OrgNode, OrgSeat, OuExecContext, ProposalSummary, VaultPrincipal, VaultRole } from './types';
+import { UpgradeBuild } from './upgrade';
+import { OrgCapabilitiesApi, OrgCurrencyApi, OrgEntriesApi, OrgFreezeApi, OrgUnitsApi, OrgUpgradeApi } from './OrgClientGroups';
+export type RunOutcome = {
+    status: 'executed';
+    digest: string;
+} | {
+    status: 'proposed';
+    digest: string;
+    proposalId?: string;
+} | {
+    status: 'blocked';
+    code: BlockCode;
+    reason: string;
+};
+export interface RunOptions {
+    unitId?: string;
+    metadataIpfs?: string;
+}
+export interface ExecuteOptions {
+    freezeAdminCapId?: string;
+    treasuryCapId?: string;
+    upgrade?: UpgradeBuild;
+    deleteFrame?: boolean;
+}
+export interface OrgHandleDeps {
+    suiClient: ClientWithCoreApi;
+    indexer: IndexerClient;
+    ids: PackageIds;
+    requireExecutor: () => TransactionExecutor;
+    address: string;
+}
+export declare class OrgHandle {
+    readonly deps: OrgHandleDeps;
+    readonly org: Org;
+    readonly nodes: OrgNode[];
+    readonly seats: OrgSeat[];
+    readonly seat: OrgSeat | null;
+    readonly governance: OrgGovernanceApi;
+    readonly members: OrgMembersApi;
+    readonly metadata: OrgMetadataApi;
+    readonly types: OrgTypesApi;
+    readonly treasury: OrgTreasuryApi;
+    readonly orders: OrgOrdersApi;
+    readonly vault: OrgVaultApi;
+    readonly currency: OrgCurrencyApi;
+    readonly units: OrgUnitsApi;
+    readonly freeze: OrgFreezeApi;
+    readonly entries: OrgEntriesApi;
+    readonly upgrade: OrgUpgradeApi;
+    readonly capabilities: OrgCapabilitiesApi;
+    private readonly govCache;
+    private readonly memberCache;
+    private readonly vaultCache;
+    constructor(deps: OrgHandleDeps, org: Org, preferredSeatDaoId?: string | null);
+    get orgId(): string;
+    as(daoId: string): OrgHandle;
+    requireSeat(): OrgSeat;
+    requireContext(): OuExecContext;
+    contextFor(unitId?: string): OuExecContext;
+    requireNode(unitId?: string): OrgNode;
+    pkgs(): ArmaturePkgs;
+    aliases(): Map<string, string>;
+    gov(daoId: string): Promise<DaoGovernance>;
+    isMember(daoId: string): Promise<boolean | undefined>;
+    capabilityVault(vaultId: string): Promise<CapabilityVaultContents>;
+    capsFor(action: OuProposalAction, ctx: OuExecContext): Promise<OuCapabilities>;
+    refresh(): void;
+    requireTreasuryId(override?: string): string;
+    submit(tx: Transaction): Promise<TxResult>;
+}
+declare class OrgGovernanceApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    read(daoId?: string): Promise<DaoGovernance>;
+    resolve(action: OuProposalAction, opts?: RunOptions): Promise<ResolvedPlan>;
+    paths(action: OuProposalAction, opts?: {
+        unitId?: string;
+    }): Promise<PathCandidate[]>;
+    run(action: OuProposalAction, opts?: RunOptions): Promise<RunOutcome>;
+    runBatch(actions: OuProposalAction[], opts?: RunOptions): Promise<RunOutcome>;
+    canComposite(actions: OuProposalAction[], opts?: {
+        unitId?: string;
+    }): Promise<CompositeEligibility>;
+    runComposite(actions: OuProposalAction[], opts?: RunOptions): Promise<RunOutcome>;
+    proposals(): Promise<ProposalSummary[]>;
+    proposal(proposalId: string): Promise<LiveProposal | null>;
+    private summary;
+    private locate;
+    vote(params: {
+        proposalId: string;
+        approve: boolean;
+        payloadType?: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+    deleteExpired(params: {
+        proposalIds: string[];
+        payloadTypes?: Record<string, string>;
+    }): Promise<TxResult>;
+    expired(): Promise<LiveProposal[]>;
+    deleteExhaustedFrame(frameId: string): Promise<TxResult>;
+    execute(proposalId: string, opts?: ExecuteOptions): Promise<TxResult>;
+    private passedContext;
+    private execPlanned;
+}
+declare class OrgMembersApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    add(addresses: string[], opts?: RunOptions): Promise<RunOutcome>;
+    remove(addresses: string[], opts?: RunOptions): Promise<RunOutcome>;
+    setBoard(change: {
+        add?: string[];
+        remove?: string[];
+    }, opts?: RunOptions): Promise<RunOutcome>;
+}
+declare class OrgMetadataApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    update(params: {
+        metadataUri: string;
+        charterId?: string;
+        unitId?: string;
+        metadataIpfs?: string;
+    }): Promise<RunOutcome>;
+}
+declare class OrgTypesApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    enable(params: {
+        typeKey: string;
+        moveType: string;
+        config: ProposalConfigInput;
+        composableAllowed?: boolean;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    disable(typeKey: string, opts?: RunOptions): Promise<RunOutcome>;
+    updateConfig(typeKey: string, patch: ProposalConfigPatch, opts?: RunOptions): Promise<RunOutcome>;
+    enableComposite(opts?: RunOptions): Promise<RunOutcome>;
+    enableSendCoin(coinType?: string, opts?: RunOptions): Promise<RunOutcome>;
+    enableSendCoinToOrg(coinType?: string, opts?: RunOptions): Promise<RunOutcome>;
+    enableSendSmallPayment(params?: {
+        coinType?: string;
+        config?: ProposalConfigInput;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    enableTrading(params?: {
+        quoteType?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+}
+declare class OrgTreasuryApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    balances(treasuryVaultId?: string): Promise<TreasuryCoinBalance[]>;
+    balance(coinType?: string, treasuryVaultId?: string): Promise<bigint>;
+    deposit(params: {
+        amount: bigint;
+        coinType?: string;
+        treasuryVaultId?: string;
+    }): Promise<TxResult>;
+    claim(params: {
+        coinObjectIds: string[];
+        coinType?: string;
+        treasuryVaultId?: string;
+    }): Promise<TxResult>;
+    send(params: {
+        recipient: string;
+        amount: bigint;
+        coinType?: string;
+        treasuryVaultId?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    sendToOrg(params: {
+        recipientTreasuryId: string;
+        amount: bigint;
+        coinType?: string;
+        treasuryVaultId?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    sendSmall(params: {
+        recipient: string;
+        amount: bigint;
+        coinType?: string;
+        treasuryVaultId?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+}
+export interface OrgSweepSkip {
+    storageUnitId: string;
+    assetId: bigint;
+    amount: bigint;
+    reason: 'no-vault' | 'unlinked';
+}
+export interface OrgLimitOrderParams extends OrderFlags {
+    storageUnitId: string;
+    assetId: string;
+    side: OrderSide;
+    price: bigint;
+    quantity: bigint;
+    expireAt?: bigint;
+    quoteType?: string;
+}
+export interface OrgCoinLimitOrderParams extends OrderFlags {
+    poolId: string;
+    baseType: string;
+    quoteType?: string;
+    side: OrderSide;
+    price: bigint;
+    quantity: bigint;
+    expireAt?: bigint;
+    depositAmount?: bigint;
+    treasuryVaultId?: string;
+}
+export interface OrgTradingAccountCreated {
+    tradingAccountId?: string;
+    tradingCustodyId?: string;
+}
+declare class OrgOrdersApi {
+    private readonly h;
+    private readonly custodies;
+    private created;
+    constructor(h: OrgHandle);
+    ensureAccount(): Promise<RunOutcome & OrgTradingAccountCreated>;
+    private target;
+    private resolvePool;
+    limit(params: OrgLimitOrderParams): Promise<RunOutcome>;
+    market(params: {
+        storageUnitId: string;
+        assetId: string;
+        side: OrderSide;
+        quantity: bigint;
+        quoteType?: string;
+        selfMatchingOption?: number;
+    }): Promise<RunOutcome>;
+    cancel(params: {
+        storageUnitId: string;
+        assetId: string;
+        orderId: bigint;
+        quoteType?: string;
+    }): Promise<RunOutcome>;
+    buyFromTreasury(params: OrgLimitOrderParams & {
+        depositAmount?: bigint;
+        treasuryVaultId?: string;
+        bidFeeRate?: bigint;
+    }): Promise<RunOutcome>;
+    sellFromVault(params: OrgLimitOrderParams & {
+        vaultId?: string;
+        vaultQuantity?: bigint;
+        registrantOrgId?: string;
+    }): Promise<RunOutcome>;
+    deposit(params: {
+        amount: bigint;
+        coinType?: string;
+        treasuryVaultId?: string;
+    }): Promise<RunOutcome>;
+    limitCoin(params: OrgCoinLimitOrderParams): Promise<RunOutcome>;
+    cancelCoin(params: {
+        poolId: string;
+        baseType: string;
+        quoteType?: string;
+        orderId: bigint;
+    }): Promise<RunOutcome>;
+    enableCoinPair(params: {
+        baseType: string;
+        quoteType?: string;
+    }): Promise<RunOutcome>;
+    createPool(params: {
+        assetId: bigint;
+        storageUnitId?: string;
+        collectionId?: string;
+        quoteType?: string;
+        treasuryVaultId?: string;
+    }): Promise<RunOutcome>;
+    sweepCoin(params: {
+        amount: bigint;
+        coinType?: string;
+        treasuryVaultId?: string;
+        claimFromPool?: string;
+        claimFromCoinPool?: {
+            poolId: string;
+            baseType: string;
+            quoteType?: string;
+        };
+    }): Promise<RunOutcome>;
+    sweepItems(params: {
+        storageUnitId: string;
+        assetId: bigint;
+        amount: bigint;
+        vaultId?: string;
+        collectionId?: string;
+        registrantOrgId?: string;
+        claimFromPool?: string;
+        quoteType?: string;
+    }): Promise<RunOutcome>;
+    sweepAll(params?: {
+        quoteType?: string;
+        treasuryVaultId?: string;
+        includeCurrency?: boolean;
+    }): Promise<RunOutcome & {
+        skipped: OrgSweepSkip[];
+    }>;
+}
+declare class OrgVaultApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    atHub(hubId: string): Promise<HubDaoVault[]>;
+    resolve(params: {
+        storageUnitId: string;
+        registrantOrgId?: string;
+    }): Promise<string | null>;
+    info(vaultId: string): Promise<OuVaultInfo | null>;
+    balance(vaultId: string, assetId: bigint): Promise<bigint>;
+    init(params: {
+        storageUnitId: string;
+        vaultConfigId?: string;
+        depositPrincipals?: VaultPrincipal[];
+        withdrawPrincipals?: VaultPrincipal[];
+        editPrincipals?: VaultPrincipal[];
+    }): Promise<TxResult>;
+    deposit(params: {
+        storageUnitId: string;
+        items: {
+            assetId: bigint;
+            amount: bigint;
+        }[];
+        registrantOrgId?: string;
+        vaultId?: string;
+    }): Promise<TxResult>;
+    withdraw(params: {
+        storageUnitId: string;
+        items: {
+            assetId: bigint;
+            amount: bigint;
+        }[];
+        to?: 'wallet' | 'hangar';
+        characterId?: string;
+        registrantOrgId?: string;
+        vaultId?: string;
+    }): Promise<TxResult>;
+    grant(params: {
+        vaultId: string;
+        grants: {
+            role: VaultRole;
+            principal: VaultPrincipal;
+        }[];
+        editorOuId?: string;
+    }): Promise<TxResult>;
+    revoke(params: {
+        vaultId: string;
+        revocations: {
+            role: VaultRole;
+            principal: VaultPrincipal;
+        }[];
+        editorOuId?: string;
+    }): Promise<TxResult>;
+    rekey(params: {
+        vaultId: string;
+        newRegistrantOrgId: string;
+        editorOuId?: string;
+    }): Promise<TxResult>;
+    deinit(params: {
+        vaultId: string;
+        editorOuId?: string;
+    }): Promise<TxResult>;
+}
+export {};

package/dist/armature/OrgClientGroups.d.ts

@@ -0,0 +1,186 @@
+import { TxResult } from '../types';
+import { FreezeState } from './governance';
+import { SpinOutConfigs } from './lifecycle';
+import { OrgHandle, RunOptions, RunOutcome } from './OrgClient';
+import { CapabilityVaultContents, EncryptedEntry } from './proposals';
+import { ProposalConfigInput } from './transactions';
+import { UpgradeBuild } from './upgrade';
+export declare class OrgCurrencyApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    private ids;
+    enable(params: {
+        coinType: string;
+        config?: ProposalConfigInput;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    adopt(params: {
+        coinType: string;
+        treasuryCapId: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    mint(params: {
+        coinType: string;
+        treasuryCapId: string;
+        amount: bigint;
+        recipient?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    mintAllowance(params: {
+        coinType: string;
+        treasuryCapId: string;
+        amount: bigint;
+        recipient?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    configureAllowance(params: {
+        coinType: string;
+        addMinters?: string[];
+        removeMinters?: string[];
+        maxPerCall?: bigint;
+        enabled?: boolean;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    mintWithAllowance(params: {
+        coinType: string;
+        treasuryCapId: string;
+        amount: bigint;
+        recipient?: string;
+        bypassCapId?: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+    burn(params: {
+        coinType: string;
+        treasuryCapId: string;
+        amount: bigint;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    returnCap(params: {
+        coinType: string;
+        treasuryCapId: string;
+        recipient: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+}
+export declare class OrgUnitsApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    private child;
+    private capType;
+    create(params: {
+        name: string;
+        board: string[];
+        metadataUri: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    pause(params: {
+        unitId: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    unpause(params: {
+        unitId: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    transferCap(params: {
+        unitId: string;
+        capId: string;
+        capType?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    reclaimCap(params: {
+        unitId: string;
+        capId: string;
+        capType?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    spinOut(params: {
+        unitId: string;
+        freezeAdminCapId?: string;
+        configs?: Partial<SpinOutConfigs>;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    spawnSuccessor(params: {
+        board: string[];
+        name: string;
+        metadataUri: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    transferAssets(params: {
+        targetOuId: string;
+        coinTypes?: string[];
+        capIds?: string[];
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    destroy(params: {
+        unitId: string;
+    }): Promise<TxResult>;
+}
+export declare class OrgFreezeApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    private freezeId;
+    read(unitId?: string): Promise<FreezeState>;
+    freezeType(params: {
+        moveType: string;
+        freezeAdminCapId: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+    unfreezeType(params: {
+        moveType: string;
+        freezeAdminCapId: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+    unfreeze(params: {
+        moveType: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    setMaxDuration(params: {
+        maxFreezeDurationMs: number;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    updateExempt(params: {
+        add?: string[];
+        remove?: string[];
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    transferAdmin(params: {
+        newAdmin: string;
+        freezeAdminCapId: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+}
+export declare class OrgEntriesApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    private unit;
+    list(unitId?: string): Promise<EncryptedEntry[]>;
+    publish(params: {
+        location: string;
+        description: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+    update(params: {
+        entryId: string;
+        location: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+    edit(params: {
+        entryId: string;
+        location: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+    rotateEpoch(params?: {
+        unitId?: string;
+    }): Promise<TxResult>;
+    remove(params: {
+        entryId: string;
+        unitId?: string;
+    }): Promise<TxResult>;
+}
+export declare class OrgUpgradeApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    propose(params: {
+        capId: string;
+        packageId: string;
+        digest: number[] | Uint8Array;
+        policy?: number;
+        build?: UpgradeBuild;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+}
+export declare class OrgCapabilitiesApi {
+    private readonly h;
+    constructor(h: OrgHandle);
+    list(unitId?: string): Promise<CapabilityVaultContents>;
+    enableBypass(params: {
+        typeKey: string;
+        moveType: string;
+        config: ProposalConfigInput;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+    disableBypass(params: {
+        moveType: string;
+        typeKey?: string;
+        capId?: string;
+    }, opts?: RunOptions): Promise<RunOutcome>;
+}

package/dist/armature/OrgsApi.d.ts

@@ -0,0 +1,69 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { IndexerClient } from '../queries';
+import { PackageIds, TransactionExecutor, TxResult } from '../types';
+import { TypeInitInput } from './create';
+import { AccessibleKeyspace, HubDaoVault, Org, OrgDirectoryPage, OrgDirectoryParams, OrgNode, OrgSearchParams, OrgSearchResult, OrgSeat, ProposalSummary } from './types';
+export declare class OrgsApi {
+    private readonly indexer;
+    private readonly requireAddress;
+    constructor(indexer: IndexerClient, requireAddress: (override?: string) => string);
+    get(orgId: string): Promise<Org>;
+    batch(orgIds: string[]): Promise<Org[]>;
+    directory(params?: OrgDirectoryParams): Promise<OrgDirectoryPage>;
+    forPlayer(address?: string): Promise<Org[]>;
+    search(q: string, params?: OrgSearchParams): Promise<OrgSearchResult[]>;
+    proposals(orgId: string): Promise<ProposalSummary[]>;
+    accessibleKeyspaces(address?: string, role?: 'grant' | 'read' | 'write'): Promise<AccessibleKeyspace[]>;
+    vaultsAtHub(hubId: string): Promise<HubDaoVault[]>;
+    nodes(orgId: string): Promise<OrgNode[]>;
+    seats(orgId: string, address?: string): Promise<OrgSeat[]>;
+    seat(orgId: string, preferredDaoId?: string | null, address?: string): Promise<OrgSeat | null>;
+    tradingAccount(orgId: string): Promise<{
+        tradingAccountId: string;
+        node: OrgNode;
+    } | null>;
+}
+export interface CreateOrgParams {
+    name: string;
+    metadataUri: string;
+    officers?: string[];
+    members?: string[];
+    board?: string[];
+    officerName?: string;
+    memberName?: string;
+    officerMetadataUri?: string;
+    memberMetadataUri?: string;
+    freezeAdmin?: string;
+    enableTrading?: boolean;
+    quoteType?: string;
+    overrides?: {
+        org?: TypeInitInput[];
+        officers?: TypeInitInput[];
+        members?: TypeInitInput[];
+    };
+}
+export interface CreatedOrg extends TxResult {
+    orgId: string;
+    officersId: string;
+    membersId: string;
+}
+export interface CreatedOu extends TxResult {
+    ouId: string | undefined;
+}
+export interface OrgsWriteDeps {
+    suiClient: ClientWithCoreApi;
+    ids: PackageIds;
+    requireExecutor: () => TransactionExecutor;
+}
+export declare class OrgsWriteApi extends OrgsApi {
+    private readonly addressOf;
+    private readonly w;
+    constructor(indexer: IndexerClient, addressOf: (override?: string) => string, w: OrgsWriteDeps);
+    create(params: CreateOrgParams): Promise<CreatedOrg>;
+    createStandalone(params: {
+        name: string;
+        metadataUri: string;
+        board?: string[];
+    }): Promise<CreatedOu>;
+    private identifyTiers;
+}

package/dist/armature/actions.d.ts

@@ -0,0 +1,75 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { OuProposalAction } from './harness';
+import { ProposalConfigInput } from './transactions';
+export interface ArmaturePkgs {
+    armature: string;
+    armatureProposals: string;
+}
+export declare const TRADING_TYPE_CONFIG: ProposalConfigInput;
+export declare const GOVERNANCE_TYPE_CONFIG: ProposalConfigInput;
+export declare const TREASURY_TYPE_CONFIG: ProposalConfigInput;
+export declare const WHOLE_BOARD_TYPE_CONFIG: ProposalConfigInput;
+export declare const COMPOSITE_TYPE_CONFIG: ProposalConfigInput;
+export declare function subOuControlType(armature: string): string;
+export declare function sendCoinTypeKey(coinType: string): string;
+export declare function sendCoinToOuTypeKey(coinType: string): string;
+export declare function genericTypeKey(name: string, typeArg: string): string;
+export declare const DEFAULT_SLOT_TYPES: Record<string, string>;
+export interface TradingTypeEntry {
+    typeKey: string;
+    moveType: string;
+    permissions: number;
+}
+export declare function tradingTypeEntries(tradingPkg: string, quoteType: string, baseTypes?: string[]): TradingTypeEntry[];
+export declare function enableProposalTypeAction(pkgs: ArmaturePkgs, opts: {
+    kind: string;
+    enabledTypeKey: string;
+    enabledMoveType: string;
+    config: ProposalConfigInput;
+    composableAllowed?: boolean;
+    fallbackPolicy?: OuProposalAction['fallbackPolicy'];
+}): OuProposalAction;
+export declare function disableProposalTypeAction(pkgs: ArmaturePkgs, typeKey: string): OuProposalAction;
+export declare function enableSendCoinAction(pkgs: ArmaturePkgs, coinType: string): OuProposalAction;
+export declare function enableSendCoinToOuAction(pkgs: ArmaturePkgs, coinType: string): OuProposalAction;
+export declare function enableCompositeAction(pkgs: ArmaturePkgs): OuProposalAction;
+export declare function enableTradingActions(pkgs: ArmaturePkgs, opts: {
+    armatureTrading: string;
+    quoteType: string;
+    alreadyEnabled?: Set<string>;
+    baseTypes?: string[];
+}): OuProposalAction[];
+export interface ProposalConfigPatch {
+    quorum?: number;
+    approvalThreshold?: number;
+    proposeThreshold?: number;
+    expiryMs?: number;
+    executionDelayMs?: number;
+    cooldownMs?: number;
+    composableAllowed?: boolean;
+    permissions?: number;
+    borrowScope?: string[];
+}
+export declare function updateProposalConfigAction(pkgs: ArmaturePkgs, targetTypeKey: string, patch?: ProposalConfigPatch): OuProposalAction;
+export declare function enableBypassTypeAction(pkgs: ArmaturePkgs, opts: {
+    typeKey: string;
+    moveType: string;
+    config: ProposalConfigInput;
+    capabilityVaultId: string;
+}): OuProposalAction;
+export declare function disableBypassTypeAction(pkgs: ArmaturePkgs, opts: {
+    typeKey: string;
+    moveType: string;
+    capId: string;
+    capabilityVaultId: string;
+}): OuProposalAction;
+export declare function addMembersAction(pkgs: ArmaturePkgs, addresses: string[]): OuProposalAction;
+export declare function removeMembersAction(pkgs: ArmaturePkgs, addresses: string[]): OuProposalAction;
+export declare function addMemberAction(pkgs: ArmaturePkgs, address: string): OuProposalAction;
+export declare function removeMemberAction(pkgs: ArmaturePkgs, address: string): OuProposalAction;
+export declare function setBoardAction(pkgs: ArmaturePkgs, change: {
+    add?: string[];
+    remove?: string[];
+}): OuProposalAction;
+export declare function updateMetadataAction(pkgs: ArmaturePkgs, metadataUri: string, charterId: string): OuProposalAction;
+export type { Transaction };