@indigo-labs/indigo-sdk/dist/index.d.ts

Indigo SDK for interacting with Indigo endpoints via lucid-evolution

import * as _lucid_evolution_lucid from '@lucid-evolution/lucid';
import { Data, UTxO, Credential, OutRef, LucidEvolution, TxBuilder, Network, WithdrawalValidator, SpendingValidator, Assets, MintingPolicy, Address, PolicyId, ScriptHash, ProtocolParameters, OutputDatum, Script, Datum } from '@lucid-evolution/lucid';
import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
import * as Core from '@evolution-sdk/evolution';
import { TSchema, Schema, Data as Data$1 } from '@evolution-sdk/evolution';
import { option, ord } from 'fp-ts';
import * as effect_Schema from 'effect/Schema';
import { Schema as Schema$1 } from 'effect';
import { Predicate } from 'fp-ts/lib/Predicate';
import Decimal from 'decimal.js';
import { ParsedPayload } from '@pythnetwork/pyth-lazer-sdk';

declare const AssetClassSchema: _lucid_evolution_lucid.TObject<{
    currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
    /** Use the HEX encoding */
    tokenName: _lucid_evolution_lucid.TUnsafe<string>;
}>;
type AssetClassD = Data.Static<typeof AssetClassSchema>;
declare function toAssetClassFromLucid(asset: AssetClassD): AssetClass;
declare function getAssetClassComparisonStr(asset: AssetClass): string;
declare const VerificationKeyHashSchema: _lucid_evolution_lucid.TUnsafe<string>;
declare const CredentialSchema: _lucid_evolution_lucid.TUnion<(_lucid_evolution_lucid.TObject<{
    PublicKeyCredential: _lucid_evolution_lucid.TTuple<[_lucid_evolution_lucid.TUnsafe<string>]>;
}> | _lucid_evolution_lucid.TObject<{
    ScriptCredential: _lucid_evolution_lucid.TTuple<[_lucid_evolution_lucid.TUnsafe<string>]>;
}>)[]>;
type CredentialD = Data.Static<typeof CredentialSchema>;
declare const CredentialD: CredentialD;
declare const StakeCredentialSchema: _lucid_evolution_lucid.TUnion<(_lucid_evolution_lucid.TObject<{
    Inline: _lucid_evolution_lucid.TTuple<[_lucid_evolution_lucid.TUnion<(_lucid_evolution_lucid.TObject<{
        PublicKeyCredential: _lucid_evolution_lucid.TTuple<[_lucid_evolution_lucid.TUnsafe<string>]>;
    }> | _lucid_evolution_lucid.TObject<{
        ScriptCredential: _lucid_evolution_lucid.TTuple<[_lucid_evolution_lucid.TUnsafe<string>]>;
    }>)[]>]>;
}> | _lucid_evolution_lucid.TObject<{
    Pointer: _lucid_evolution_lucid.TTuple<[_lucid_evolution_lucid.TObject<{
        slotNumber: _lucid_evolution_lucid.TUnsafe<bigint>;
        transactionIndex: _lucid_evolution_lucid.TUnsafe<bigint>;
        certificateIndex: _lucid_evolution_lucid.TUnsafe<bigint>;
    }>]>;
}>)[]>;
type StakeCredential = Data.Static<typeof StakeCredentialSchema>;
declare const StakeCredential: StakeCredential;
type ParsedOutput<T> = {
    utxo: UTxO;
    datum: T;
};

declare const PythConfigurationSchema: TSchema.Struct<{
    priceFeedId: TSchema.Integer;
}>;
type PythConfiguration = typeof PythConfigurationSchema.Type;
declare const DerivedPythPriceSchema: TSchema.Union<[TSchema.Struct<{
    Value: TSchema.Struct<{
        configuration: TSchema.Struct<{
            priceFeedId: TSchema.Integer;
        }>;
    }>;
}>, TSchema.Struct<{
    Inverse: TSchema.Struct<{
        value: Schema.SchemaClass<Data$1.Data, Data$1.Data, never>;
    }>;
}>, TSchema.Struct<{
    Divide: TSchema.Struct<{
        x: Schema.SchemaClass<Data$1.Data, Data$1.Data, never>;
        y: Schema.SchemaClass<Data$1.Data, Data$1.Data, never>;
    }>;
}>]>;
type DerivedPythPrice = typeof DerivedPythPriceSchema.Type;
declare function fromDataDerivedPythPrice(data: Data$1.Data): DerivedPythPrice;
declare function toDataDerivedPythPrice(derivedPythPrice: DerivedPythPrice): Data$1.Data;
declare const PythFeedParamsSchema: TSchema.Struct<{
    config: TSchema.Union<[TSchema.Struct<{
        Value: TSchema.Struct<{
            configuration: TSchema.Struct<{
                priceFeedId: TSchema.Integer;
            }>;
        }>;
    }>, TSchema.Struct<{
        Inverse: TSchema.Struct<{
            value: Schema.SchemaClass<Data$1.Data, Data$1.Data, never>;
        }>;
    }>, TSchema.Struct<{
        Divide: TSchema.Struct<{
            x: Schema.SchemaClass<Data$1.Data, Data$1.Data, never>;
            y: Schema.SchemaClass<Data$1.Data, Data$1.Data, never>;
        }>;
    }>]>;
    pythStatePolicyId: TSchema.ByteArray;
}>;
type PythFeedParams = typeof PythFeedParamsSchema.Type;
declare function serialisePythFeedParams(params: PythFeedParams): Data$1.Data;
declare const PythFeedRedeemerSchema: TSchema.Struct<{
    price: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    auxiliaryData: Schema.SchemaClass<Data$1.Data, Data$1.Data, never>;
}>;
type PythFeedRedeemer = typeof PythFeedRedeemerSchema.Type;
declare function serialisePythFeedRedeemer(r: PythFeedRedeemer): string;
/**
 * IntervalBoundType
 * A type of interval bound. The value for the `Finite` case typically
 represents a number of seconds or milliseconds.
 */
declare const AikenIntervalIntervalBoundType: TSchema.Union<[TSchema.Struct<{
    _tag: TSchema.Literal<["NegativeInfinity"]>;
}>, TSchema.Struct<{
    _tag: TSchema.Literal<["Finite"]>;
} & {
    finite: TSchema.Integer;
}>, TSchema.Struct<{
    _tag: TSchema.Literal<["PositiveInfinity"]>;
}>]>;
/**
 * IntervalBound
 * An interval bound, either inclusive or exclusive.
 */
declare const AikenIntervalIntervalBound: TSchema.Struct<{
    bound_type: TSchema.Union<[TSchema.Struct<{
        _tag: TSchema.Literal<["NegativeInfinity"]>;
    }>, TSchema.Struct<{
        _tag: TSchema.Literal<["Finite"]>;
    } & {
        finite: TSchema.Integer;
    }>, TSchema.Struct<{
        _tag: TSchema.Literal<["PositiveInfinity"]>;
    }>]>;
    is_inclusive: TSchema.Boolean;
}>;
/**
 * ValidityRange
 * A type to represent intervals of values. Interval are inhabited by an
 integer value representing  have a finite lower-bound and/or upper-bound.
 This allows to represent all kind of mathematical intervals:
 ```aiken
 // [1; 10]
 let i0: Interval = Interval
   { lower_bound:
       IntervalBound { bound_type: Finite(1), is_inclusive: True }
   , upper_bound:
       IntervalBound { bound_type: Finite(10), is_inclusive: True }
   }
 ```
 ```aiken
 // (20; infinity)
 let i1: Interval = Interval
   { lower_bound:
       IntervalBound { bound_type: Finite(20), is_inclusive: False }
   , upper_bound:
       IntervalBound { bound_type: PositiveInfinity, is_inclusive: False }
   }
 ```
 */
declare const CardanoTransactionValidityRange: TSchema.Struct<{
    lower_bound: TSchema.Struct<{
        bound_type: TSchema.Union<[TSchema.Struct<{
            _tag: TSchema.Literal<["NegativeInfinity"]>;
        }>, TSchema.Struct<{
            _tag: TSchema.Literal<["Finite"]>;
        } & {
            finite: TSchema.Integer;
        }>, TSchema.Struct<{
            _tag: TSchema.Literal<["PositiveInfinity"]>;
        }>]>;
        is_inclusive: TSchema.Boolean;
    }>;
    upper_bound: TSchema.Struct<{
        bound_type: TSchema.Union<[TSchema.Struct<{
            _tag: TSchema.Literal<["NegativeInfinity"]>;
        }>, TSchema.Struct<{
            _tag: TSchema.Literal<["Finite"]>;
        } & {
            finite: TSchema.Integer;
        }>, TSchema.Struct<{
            _tag: TSchema.Literal<["PositiveInfinity"]>;
        }>]>;
        is_inclusive: TSchema.Boolean;
    }>;
}>;
declare const PythStateDatumSchema: TSchema.Struct<{
    governance: TSchema.Struct<{
        wormhole: TSchema.ByteArray;
        emitterChain: TSchema.Integer;
        emitterAddress: TSchema.ByteArray;
        seenSequence: TSchema.Integer;
    }>;
    trustedSigners: TSchema.Map<TSchema.ByteArray, TSchema.Struct<{
        lower_bound: TSchema.Struct<{
            bound_type: TSchema.Union<[TSchema.Struct<{
                _tag: TSchema.Literal<["NegativeInfinity"]>;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["Finite"]>;
            } & {
                finite: TSchema.Integer;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["PositiveInfinity"]>;
            }>]>;
            is_inclusive: TSchema.Boolean;
        }>;
        upper_bound: TSchema.Struct<{
            bound_type: TSchema.Union<[TSchema.Struct<{
                _tag: TSchema.Literal<["NegativeInfinity"]>;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["Finite"]>;
            } & {
                finite: TSchema.Integer;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["PositiveInfinity"]>;
            }>]>;
            is_inclusive: TSchema.Boolean;
        }>;
    }>>;
    deprecatedWithdrawScripts: TSchema.Map<TSchema.Struct<{
        lower_bound: TSchema.Struct<{
            bound_type: TSchema.Union<[TSchema.Struct<{
                _tag: TSchema.Literal<["NegativeInfinity"]>;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["Finite"]>;
            } & {
                finite: TSchema.Integer;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["PositiveInfinity"]>;
            }>]>;
            is_inclusive: TSchema.Boolean;
        }>;
        upper_bound: TSchema.Struct<{
            bound_type: TSchema.Union<[TSchema.Struct<{
                _tag: TSchema.Literal<["NegativeInfinity"]>;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["Finite"]>;
            } & {
                finite: TSchema.Integer;
            }>, TSchema.Struct<{
                _tag: TSchema.Literal<["PositiveInfinity"]>;
            }>]>;
            is_inclusive: TSchema.Boolean;
        }>;
    }>, TSchema.ByteArray>;
    withdraw_script: TSchema.ByteArray;
}>;
type PythStateDatum = typeof PythStateDatumSchema.Type;
declare function serialisePythStateDatum(r: PythStateDatum): string;
declare function parsePythStateDatum(datum: string): PythStateDatum;
declare const PythUpdatesRedeemerSchema: TSchema.Array<TSchema.ByteArray>;
type PythUpdatesRedeemer = typeof PythUpdatesRedeemerSchema.Type;
declare function serialisePythUpdatesRedeemer(r: PythUpdatesRedeemer): string;

interface CurrencySymbolSP {
    unCurrencySymbol: string;
}
interface TokenNameSP {
    unTokenName: string;
}
/**
 * AssetClassSP used in System Params
 */
type AssetClassSP = [CurrencySymbolSP, TokenNameSP];
type PythPriceConfigurationSP = {
    priceFeedId: number;
};
type DerivedPythPriceSP = {
    tag: 'value';
    val: PythPriceConfigurationSP;
} | {
    tag: 'inverse';
    val: DerivedPythPriceSP;
} | {
    tag: 'divide';
    val: [DerivedPythPriceSP, DerivedPythPriceSP];
};
type PythFeedParamsSP = {
    config: DerivedPythPriceSP;
    pythStatePolicyId: CurrencySymbolSP;
};
declare function fromSysParamsDerivedPythPrice(cfg: DerivedPythPriceSP): DerivedPythPrice;
declare function fromSysParamsPythFeedParams(params: PythFeedParamsSP): PythFeedParams;
type PythFeedConfig = {
    params: PythFeedParamsSP;
    pythFeedValHash: string;
    pythFeedValScriptRef: ScriptReference;
};
type PythConfig = {
    pythStateAssetClass: AssetClassSP;
    /**
     * Key is in the format: "iAsset.ascii/Collateral.currency.hex.Collateral.tokenName.hex".
     * Use the `getPythFeedConfig` helper to querying.
     */
    pythFeeds: {
        [key: string]: PythFeedConfig;
    };
};
declare function getPythFeedConfig(cfg: PythConfig, iasset: Uint8Array<ArrayBufferLike>, collateralAsset: AssetClass): PythFeedConfig;
interface SystemParams {
    versionRecordParams: VersionRecordParams;
    validatorHashes: ValidatorHashes;
    treasuryParams: TreasuryParamsSP;
    startTime: StartTime;
    stakingParams: StakingParamsSP;
    stabilityPoolParams: StabilityPoolParamsSP;
    stableswapParams: StableswapParamsSP;
    scriptReferences: ScriptReferences;
    pollShardParams: PollShardParamsSP;
    pollManagerParams: PollManagerParamsSP;
    robParams: RobParamsSP;
    interestCollectionParams: InterestCollectionParamsSP;
    indyToken: AssetClassSP;
    govParams: GovParamsSP;
    executeParams: ExecuteParamsSP;
    collectorParams: CollectorParamsSP;
    cdpParams: CdpParamsSP;
    cdpCreatorParams: CDPCreatorParamsSP;
    cdpRedeemParams: CdpRedeemParamsSP;
    iassetParams: IAssetParamsSP;
    pythConfig: PythConfig;
}
type ValidatorHashes = {
    versionRegistryHash: string;
    treasuryHash: string;
    stableswapHash: string;
    stakingHash: string;
    stabilityPoolHash: string;
    pollShardHash: string;
    pollManagerHash: string;
    robHash: string;
    interestCollectionHash: string;
    govHash: string;
    executeHash: string;
    collectorHash: string;
    cdpHash: string;
    cdpCreatorHash: string;
    iassetHash: string;
};
interface AddressCredential {
    tag: string;
    contents: PubKeyHash;
}
interface ScriptCredential {
    tag: string;
    contents: {
        tag: string;
        contents: string;
    };
}
interface PubKeyHash {
    getPubKeyHash: string;
}
interface VersionRecordParams {
    upgradeToken: AssetClassSP;
}
interface TreasuryParamsSP {
    upgradeToken: AssetClassSP;
    versionRecordToken: AssetClassSP;
    treasuryUtxosStakeCredential: ScriptCredential | undefined;
}
interface StartTime {
    slot: number;
    blockHeader: string;
}
interface StakingParamsSP {
    versionRecordToken: AssetClassSP;
    stakingToken: AssetClassSP;
    stakingManagerNFT: AssetClassSP;
    pollToken: AssetClassSP;
    indyToken: AssetClassSP;
    collectorValHash: string;
}
interface StabilityPoolParamsSP {
    versionRecordToken: AssetClassSP;
    stabilityPoolToken: AssetClassSP;
    snapshotEpochToScaleToSumToken: AssetClassSP;
    iAssetAuthToken: AssetClassSP;
    iassetValHash: string;
    cdpToken: AssetClassSP;
    assetSymbol: CurrencySymbolSP;
    accountToken: AssetClassSP;
    accountCreateFeeLovelaces: number;
    accountProcessingCooldownMs: number;
    accountProcessingBiasMs: number;
    stakeCredential: ScriptCredential | undefined;
}
interface StableswapParamsSP {
    iassetSymbol: CurrencySymbolSP;
    cdpToken: AssetClassSP;
    versionRecordToken: AssetClassSP;
    cdpValHash: string;
    treasuryValHash: string;
}
interface ScriptReferences {
    versionRegistryValidatorRef: ScriptReference;
    treasuryValidatorRef: ScriptReference;
    stakingValidatorRef: ScriptReference;
    stabilityPoolValidatorRef: ScriptReference;
    stableswapValidatorRef: ScriptReference;
    pollShardValidatorRef: ScriptReference;
    pollManagerValidatorRef: ScriptReference;
    robValidatorRef: ScriptReference;
    interestCollectionValidatorRef: ScriptReference;
    iAssetTokenPolicyRef: ScriptReference;
    governanceValidatorRef: ScriptReference;
    executeValidatorRef: ScriptReference;
    collectorValidatorRef: ScriptReference;
    cdpValidatorRef: ScriptReference;
    cdpCreatorValidatorRef: ScriptReference;
    cdpRedeemValidatorRef: ScriptReference;
    iassetValidatorRef: ScriptReference;
    authTokenPolicies: AuthTokenPolicies;
}
interface Output {
    scriptRef: ScriptRef;
    output: ScriptOutput;
}
interface ScriptRef {
    tag: string;
    contents?: string[] | null;
}
interface ScriptOutput {
    referenceScript: string;
    datum: AddressCredentialOrDatum;
    amount: Amount;
    address: AddressSP;
}
interface AddressCredentialOrDatum {
    tag: string;
    contents: string;
}
interface Amount {
    getValue?: ((CurrencySymbolSP | (number[] | null)[] | null)[] | null)[] | null;
}
interface AddressSP {
    addressStakingCredential?: null;
    addressCredential: AddressCredentialOrDatum;
}
interface Input {
    transactionId: string;
    index: number;
}
interface ScriptReference {
    output?: Output;
    input: Input;
}
interface AuthTokenPolicies {
    upgradeTokenRef: ScriptReference;
    stakingTokenRef: ScriptReference;
    stabilityPoolTokenRef: ScriptReference;
    stabilityPoolAuthTokenRef: ScriptReference;
    snapshotEpochToScaleToSumTokenRef: ScriptReference;
    pollManagerTokenRef: ScriptReference;
    iAssetAuthTokenRef: ScriptReference;
    iAssetTokenRef: ScriptReference;
    collateralAssetTokenRef: ScriptReference;
    cdpAuthTokenRef: ScriptReference;
    accountTokenRef: ScriptReference;
    versionRecordTokenPolicyRef: ScriptReference;
}
interface RobParamsSP {
    versionRecordToken: AssetClassSP;
    iassetAuthToken: AssetClassSP;
    collateralAssetAuthToken: AssetClassSP;
    iassetValHash: string;
    iassetPolicyId: CurrencySymbolSP;
}
interface InterestCollectionParamsSP {
    versionRecordNft: AssetClassSP;
    multisigUtxoNft: AssetClassSP;
    cdpAuthTk: AssetClassSP;
    collateralAssetAuthTk: AssetClassSP;
    govAuthTk: AssetClassSP;
    cdpAssetSymbol: CurrencySymbolSP;
    cdpBiasTime: bigint;
    interestSettlementCooldown: bigint;
}
interface PollShardParamsSP {
    stakingValHash: string;
    stakingToken: AssetClassSP;
    pollToken: AssetClassSP;
    indyAsset: AssetClassSP;
}
interface PollManagerParamsSP {
    upgradeToken: AssetClassSP;
    treasuryValHash: string;
    shardsValHash: string;
    pollToken: AssetClassSP;
    pBiasTime: bigint;
    indyAsset: AssetClassSP;
    govNFT: AssetClassSP;
    govExecuteValHash: string;
}
interface GovParamsSP {
    versionRecordToken: AssetClassSP;
    upgradeToken: AssetClassSP;
    pollToken: AssetClassSP;
    pollManagerValHash: string;
    iassetValHash: string;
    indyAsset: AssetClassSP;
    iAssetAuthToken: AssetClassSP;
    govNFT: AssetClassSP;
    gBiasTime: bigint;
    daoIdentityToken: AssetClassSP;
    iassetSymbol: CurrencySymbolSP;
}
interface ExecuteParamsSP {
    govNFT: AssetClassSP;
    upgradeToken: AssetClassSP;
    iAssetToken: AssetClassSP;
    collateralAssetToken: AssetClassSP;
    stabilityPoolToken: AssetClassSP;
    cdpCreatorToken: AssetClassSP;
    cdpToken: AssetClassSP;
    versionRecordToken: AssetClassSP;
    iassetValHash: string;
    cdpValHash: string;
    sPoolValHash: string;
    versionRegistryValHash: string;
    treasuryValHash: string;
}
interface CollectorParamsSP {
    versionRecordToken: AssetClassSP;
    stakingToken: AssetClassSP;
    stakingManagerNFT: AssetClassSP;
}
interface CdpRedeemParamsSP {
    treasuryValHash: string;
    iassetValHash: string;
    partialRedemptionExtraFeeLovelace: number;
    iAssetAuthToken: AssetClassSP;
    collateralAssetAuthToken: AssetClassSP;
    govNFT: AssetClassSP;
    interestCollectorValHash: string;
    cdpAuthToken: AssetClassSP;
    cdpAssetSymbol: CurrencySymbolSP;
    biasTime: bigint;
}
interface CdpParamsSP {
    upgradeToken: AssetClassSP;
    versionRecordToken: AssetClassSP;
    treasuryValHash: string;
    stabilityPoolAuthToken: AssetClassSP;
    spValHash: string;
    iassetValHash: string;
    iAssetAuthToken: AssetClassSP;
    collateralAssetAuthToken: AssetClassSP;
    interestCollectorValHash: string;
    cdpRedeemValHash: string;
    cdpAuthToken: AssetClassSP;
    cdpAssetSymbol: CurrencySymbolSP;
    biasTime: bigint;
}
interface IAssetParamsSP {
    upgradeToken: AssetClassSP;
    versionRecordToken: AssetClassSP;
}
interface CDPCreatorParamsSP {
    versionRecordToken: AssetClassSP;
    upgradeToken: AssetClassSP;
    iAssetAuthTk: AssetClassSP;
    collateralAssetAuthTk: AssetClassSP;
    treasuryValHash: string;
    cdpScriptHash: string;
    iassetValHash: string;
    cdpCreatorNft: AssetClassSP;
    cdpAuthTk: AssetClassSP;
    cdpAssetCs: CurrencySymbolSP;
    biasTime: bigint;
}
declare function toSystemParamsAsset(asset: AssetClass): AssetClassSP;
declare function fromSystemParamsAsset(asset: AssetClassSP): AssetClass;
declare function fromSystemParamsAssetLucid(asset: AssetClassSP): AssetClassD;
declare function fromSystemParamsScriptRef(ref: ScriptReference): OutRef;
declare function fromSysParamsCredential(cred: ScriptCredential): Credential;
declare function fromSysParamsStakeCredential(cred: ScriptCredential): StakeCredential;

declare function openCdp(collateralAmount: bigint, mintedAmount: bigint, sysParams: SystemParams, cdpCreatorOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, priceOracleOref: OutRef | undefined, interestOracleOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, lucid: LucidEvolution, currentSlot: number, pythMessage?: string | undefined, pythStateOref?: OutRef | undefined): Promise<TxBuilder>;
declare function adjustCdp(collateralAdjustment: bigint, debtAdjustment: bigint, cdpOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, priceOracleOref: OutRef | undefined, interestOracleOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, interestCollectorOref: OutRef, sysParams: SystemParams, lucid: LucidEvolution, currentSlot: number, pythMessage?: string | undefined, pythStateOref?: OutRef | undefined): Promise<TxBuilder>;
declare function depositCdp(amount: bigint, cdpOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, interestOracleOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, interestCollectorOref: OutRef, params: SystemParams, lucid: LucidEvolution, currentSlot: number): Promise<TxBuilder>;
declare function withdrawCdp(amount: bigint, cdpOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, priceOracleOref: OutRef | undefined, interestOracleOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, interestCollectorOref: OutRef, params: SystemParams, lucid: LucidEvolution, currentSlot: number, pythMessage?: string | undefined, pythStateOref?: OutRef | undefined): Promise<TxBuilder>;
declare function mintCdp(amount: bigint, cdpOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, priceOracleOref: OutRef | undefined, interestOracleOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, interestCollectorOref: OutRef, params: SystemParams, lucid: LucidEvolution, currentSlot: number, pythMessage?: string | undefined, pythStateOref?: OutRef | undefined): Promise<TxBuilder>;
declare function burnCdp(amount: bigint, cdpOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, interestOracleOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, interestCollectorOref: OutRef, params: SystemParams, lucid: LucidEvolution, currentSlot: number): Promise<TxBuilder>;
declare function closeCdp(cdpOref: OutRef, collateralAssetOref: OutRef, interestOracleOref: OutRef, interestCollectorOref: OutRef, sysParams: SystemParams, lucid: LucidEvolution, currentSlot: number): Promise<TxBuilder>;
declare function redeemCdp(
/**
 * When the goal is to redeem the maximum possible, just pass in the total minted amount of the CDP.
 * The logic will automatically cap the amount to the max.
 */
attemptedRedemptionIAssetAmt: bigint, cdpOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, priceOracleOref: OutRef | undefined, interestOracleOref: OutRef, interestCollectorOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, govOref: OutRef, sysParams: SystemParams, lucid: LucidEvolution, currentSlot: number, pythMessage?: string | undefined, _pythStateOref?: OutRef | undefined): Promise<TxBuilder>;
declare function freezeCdp(cdpOref: OutRef, iassetOref: OutRef, collateralAssetOref: OutRef, priceOracleOref: OutRef | undefined, interestOracleOref: OutRef, sysParams: SystemParams, lucid: LucidEvolution, currentSlot: number, pythMessage?: string | undefined, pythStateOref?: OutRef | undefined): Promise<TxBuilder>;
declare function liquidateCdp(cdpOref: OutRef, stabilityPoolOref: OutRef, interestCollectorOref: OutRef, 
/**
 * `undefined` in case using direct treasury payment.
 */
treasuryOref: OutRef | undefined, sysParams: SystemParams, lucid: LucidEvolution): Promise<TxBuilder>;
declare function mergeCdps(cdpsToMergeUtxos: OutRef[], sysParams: SystemParams, lucid: LucidEvolution): Promise<TxBuilder>;

declare const InterestOracleDatumSchema: TSchema.Struct<{
    unitaryInterest: TSchema.Integer;
    interestRate: TSchema.Struct<{
        getOnChainInt: TSchema.Integer;
    }>;
    lastUpdated: TSchema.Integer;
}>;
type InterestOracleDatum = typeof InterestOracleDatumSchema.Type;
declare const InterestOracleRedeemerSchema: TSchema.Struct<{
    newInterestRate: TSchema.Struct<{
        getOnChainInt: TSchema.Integer;
    }>;
    currentTime: TSchema.Integer;
}>;
type InterestOracleRedeemer = typeof InterestOracleRedeemerSchema.Type;
declare function serialiseFeedInterestOracleRedeemer(redeemer: InterestOracleRedeemer): string;
declare function parseInterestOracleDatum(datum: string): InterestOracleDatum;
declare function serialiseInterestOracleDatum(datum: InterestOracleDatum): string;

declare const CdpRedeemerSchema: TSchema.Union<[TSchema.Struct<{
    AdjustCdp: TSchema.Struct<{
        currentTime: TSchema.Integer;
        debtAdjustment: TSchema.Integer;
        collateralAdjustment: TSchema.Integer;
        priceOracleIdx: TSchema.Union<[TSchema.Struct<{
            OracleRefInputIdx: TSchema.Integer;
        }>, TSchema.Struct<{
            OracleOutputIdx: TSchema.Integer;
        }>, TSchema.Literal<["OracleVoid"]>]>;
    }>;
}>, TSchema.Struct<{
    CloseCdp: TSchema.Struct<{
        currentTime: TSchema.Integer;
    }>;
}>, TSchema.Literal<["RedeemCdp"]>, TSchema.Struct<{
    FreezeCdp: TSchema.Struct<{
        currentTime: TSchema.Integer;
        priceOracleIdx: TSchema.Union<[TSchema.Struct<{
            OracleRefInputIdx: TSchema.Integer;
        }>, TSchema.Struct<{
            OracleOutputIdx: TSchema.Integer;
        }>, TSchema.Literal<["OracleVoid"]>]>;
    }>;
}>, TSchema.Literal<["MergeCdps"]>, TSchema.Struct<{
    MergeAuxiliary: TSchema.Struct<{
        mainMergeUtxo: TSchema.Struct<{
            txHash: TSchema.ByteArray;
            outputIndex: TSchema.Integer;
        }>;
    }>;
}>, TSchema.Literal<["Liquidate"]>, TSchema.Struct<{
    SettleInterest: TSchema.Struct<{
        interestCollectorInputIndex: TSchema.Integer;
    }>;
}>, TSchema.Struct<{
    Stableswap: TSchema.Struct<{
        forwardingInputIndex: TSchema.Integer;
    }>;
}>, TSchema.Literal<["UpgradeVersion"]>]>;
type CdpRedeemer = typeof CdpRedeemerSchema.Type;
declare const RedeemCdpWithdrawalRedeemerSchema: TSchema.Struct<{
    cdpOutReference: TSchema.Struct<{
        txHash: TSchema.ByteArray;
        outputIndex: TSchema.Integer;
    }>;
    currentTime: TSchema.Integer;
    priceOracleIdx: TSchema.Union<[TSchema.Struct<{
        OracleRefInputIdx: TSchema.Integer;
    }>, TSchema.Struct<{
        OracleOutputIdx: TSchema.Integer;
    }>, TSchema.Literal<["OracleVoid"]>]>;
}>;
type RedeemCdpWithdrawalRedeemer = typeof RedeemCdpWithdrawalRedeemerSchema.Type;
declare const CDPContentSchema: TSchema.Struct<{
    cdpOwner: TSchema.NullOr<TSchema.ByteArray>;
    iasset: TSchema.ByteArray;
    collateralAsset: TSchema.Struct<{
        currencySymbol: TSchema.ByteArray;
        tokenName: TSchema.ByteArray;
    }>;
    mintedAmt: TSchema.Integer;
    cdpFees: TSchema.Union<[TSchema.Struct<{
        ActiveCDPInterestTracking: TSchema.Struct<{
            lastSettled: TSchema.Integer;
            unitaryInterestSnapshot: TSchema.Integer;
        }>;
    }>, TSchema.Struct<{
        FrozenCDPAccumulatedFees: TSchema.Struct<{
            iassetInterest: TSchema.Integer;
            collateralTreasury: TSchema.Integer;
        }>;
    }>]>;
}>;
type CDPContent = typeof CDPContentSchema.Type;
declare const StableswapPoolContentSchema: TSchema.Struct<{
    /** Use the HEX encoding */
    iasset: TSchema.ByteArray;
    collateralAsset: TSchema.Struct<{
        currencySymbol: TSchema.ByteArray;
        tokenName: TSchema.ByteArray;
    }>;
    collateralToIassetRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    mintingFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    redemptionFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    mintingEnabled: TSchema.Boolean;
    redemptionEnabled: TSchema.Boolean;
    feeManager: TSchema.NullOr<TSchema.ByteArray>;
    minMintOrderAmount: TSchema.Integer;
    minRedemptionOrderAmount: TSchema.Integer;
    stableswapValHash: TSchema.ByteArray;
}>;
type StableswapPoolContent = typeof StableswapPoolContentSchema.Type;
declare const CDPDatumSchema: TSchema.Union<[TSchema.Struct<{
    CDP: TSchema.Struct<{
        cdpOwner: TSchema.NullOr<TSchema.ByteArray>;
        iasset: TSchema.ByteArray;
        collateralAsset: TSchema.Struct<{
            currencySymbol: TSchema.ByteArray;
            tokenName: TSchema.ByteArray;
        }>;
        mintedAmt: TSchema.Integer;
        cdpFees: TSchema.Union<[TSchema.Struct<{
            ActiveCDPInterestTracking: TSchema.Struct<{
                lastSettled: TSchema.Integer;
                unitaryInterestSnapshot: TSchema.Integer;
            }>;
        }>, TSchema.Struct<{
            FrozenCDPAccumulatedFees: TSchema.Struct<{
                iassetInterest: TSchema.Integer;
                collateralTreasury: TSchema.Integer;
            }>;
        }>]>;
    }>;
}>, TSchema.Struct<{
    StableswapPool: TSchema.Struct<{
        /** Use the HEX encoding */
        iasset: TSchema.ByteArray;
        collateralAsset: TSchema.Struct<{
            currencySymbol: TSchema.ByteArray;
            tokenName: TSchema.ByteArray;
        }>;
        collateralToIassetRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        mintingFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        redemptionFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        mintingEnabled: TSchema.Boolean;
        redemptionEnabled: TSchema.Boolean;
        feeManager: TSchema.NullOr<TSchema.ByteArray>;
        minMintOrderAmount: TSchema.Integer;
        minRedemptionOrderAmount: TSchema.Integer;
        stableswapValHash: TSchema.ByteArray;
    }>;
}>]>;
type CDPDatum = typeof CDPDatumSchema.Type;
declare function serialiseCdpRedeemer(r: CdpRedeemer): string;
declare function parseCdpRedeemer(datum: string): option.Option<CdpRedeemer>;
declare function parseCdpRedeemerOrThrow(datum: string): CdpRedeemer;
declare function serialiseRedeemCdpWithdrawalRedeemer(r: RedeemCdpWithdrawalRedeemer): string;
declare function serialiseCdpDatum(d: CDPContent): string;
declare function serialiseStableswapPoolDatum(d: StableswapPoolContent): string;
declare function parseCdpDatum(datum: string): option.Option<CDPContent>;
declare function parseCdpDatumOrThrow(datum: string): CDPContent;
declare function parseStableswapPoolDatum(datum: string): option.Option<StableswapPoolContent>;
declare function parseStableswapPoolDatumOrThrow(datum: string): StableswapPoolContent;

declare const RationalSchema: TSchema.Struct<{
    numerator: TSchema.Integer;
    denominator: TSchema.Integer;
}>;
type Rational = typeof RationalSchema.Type;
declare const rationalZero: Rational;
declare function rationalFromInt(a: bigint): Rational;
declare function rationalFloor(a: Rational): bigint;
declare function rationalCeil(a: Rational): bigint;
declare function rationalNegate(a: Rational): Rational;
declare function rationalAdd(a: Rational, b: Rational): Rational;
declare function rationalSub(a: Rational, b: Rational): Rational;
declare function rationalMul(a: Rational, b: Rational): Rational;
declare function rationalDiv(a: Rational, b: Rational): Rational;
declare function rationalToFloat(a: Rational): number;

/**
 * Amount of iasset equal in value to the given number of collateral amount.
 */
declare function iassetValueOfCollateral(collateralAmt: bigint, oraclePrice: Rational): bigint;
/**
 * This is mostly for debugging purposes.
 */
declare function cdpCollateralRatioPercentage(currentSlot: number, iassetPrice: Rational, cdpUtxo: UTxO, cdpContent: CDPContent, interestOracleDatum: InterestOracleDatum, network: Network): number;
/**
 * The amount of iassets to redeem to reach the RMR.
 */
declare function calculateIAssetRedemptionAmt(collateralAmt: bigint, mintedAmt: bigint, price: Rational, rmr: Rational): bigint;
/**
 * Calculates the allowable redemption amount so the min collateral constraint still holds.
 * It caps the redemption amount to still satisfy the min collateral.
 *
 * Returns uncapped max iassets /\ capped max iassets
 *
 * The derived calculation comes from the following equation where:
 * c - collateral
 * m - min collateral
 * r - reimburstment ratio
 * x - redemption amount
 *
 * `c - x + r * x = m`
 * `-x + r * x = m - c`
 * `x * (r - 1) = m - c`
 * `x = (m - c) / r - 1`
 */
declare function calculateMinCollateralCappedIAssetRedemptionAmt(collateralAmt: bigint, mintedAmt: bigint, price: Rational, rmr: Rational, reimbursementRatio: Rational, minCollateral: bigint): {
    uncappedIAssetRedemptionAmt: bigint;
    cappedIAssetRedemptionAmt: bigint;
};
declare function adjustPriceToDecimals(extraDecimals: bigint, price: Rational): Rational;

declare const CdpParamsSchema: _lucid_evolution_lucid.TObject<{
    cdp_auth_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    cdp_asset_symbol: _lucid_evolution_lucid.TUnsafe<string>;
    iasset_auth_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    collateral_asset_auth_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    stability_pool_auth_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    upgrade_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    version_record_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    interest_collector_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    sp_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    iasset_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    treasury_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    cdp_redeem_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    bias_time: _lucid_evolution_lucid.TUnsafe<bigint>;
}>;
type CdpParams = Data.Static<typeof CdpParamsSchema>;
declare function castCdpParams(params: CdpParams): Data;
declare const CdpRedeemParamsSchema: _lucid_evolution_lucid.TObject<{
    cdp_auth_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    cdp_asset_symbol: _lucid_evolution_lucid.TUnsafe<string>;
    iasset_auth_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    collateral_asset_auth_token: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    interest_collector_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    iasset_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    treasury_val_hash: _lucid_evolution_lucid.TUnsafe<string>;
    gov_nft: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    partial_redemption_extra_fee_lovelace: _lucid_evolution_lucid.TUnsafe<bigint>;
    bias_time: _lucid_evolution_lucid.TUnsafe<bigint>;
}>;
type CdpRedeemParams = Data.Static<typeof CdpRedeemParamsSchema>;
declare function castCdpRedeemParams(params: CdpRedeemParams): Data;

declare const mkCdpValidatorFromSP: (params: CdpParamsSP) => SpendingValidator;
declare const mkCdpRedeemValidatorFromSP: (params: CdpRedeemParamsSP) => WithdrawalValidator;

declare const CDPCreatorParamsSchema: _lucid_evolution_lucid.TObject<{
    cdpCreatorNft: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    cdpAssetCs: _lucid_evolution_lucid.TUnsafe<string>;
    cdpAuthTk: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    iAssetAuthTk: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    collateralAssetAuthTk: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    upgradeToken: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    versionRecordToken: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    cdpScriptHash: _lucid_evolution_lucid.TUnsafe<string>;
    treasuryValHash: _lucid_evolution_lucid.TUnsafe<string>;
    iassetValHash: _lucid_evolution_lucid.TUnsafe<string>;
    biasTime: _lucid_evolution_lucid.TUnsafe<bigint>;
}>;
type CDPCreatorParams = Data.Static<typeof CDPCreatorParamsSchema>;
declare const CDPCreatorParams: CDPCreatorParams;
declare function castCDPCreatorParams(params: CDPCreatorParams): Data;

declare const mkCDPCreatorValidator: (params: CDPCreatorParams) => SpendingValidator;
declare const mkCDPCreatorValidatorFromSP: (params: CDPCreatorParamsSP) => SpendingValidator;

declare const PollManagerParamsSchema: _lucid_evolution_lucid.TObject<{
    govNFT: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    pollToken: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    upgradeToken: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    indyAsset: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    govExecuteValHash: _lucid_evolution_lucid.TUnsafe<string>;
    pBiasTime: _lucid_evolution_lucid.TUnsafe<bigint>;
    shardValHash: _lucid_evolution_lucid.TUnsafe<string>;
    treasuryValHash: _lucid_evolution_lucid.TUnsafe<string>;
}>;
type PollManagerParams = Data.Static<typeof PollManagerParamsSchema>;
declare const PollManagerParams: PollManagerParams;
declare function castPollManagerParams(params: PollManagerParams): Data;

declare const PollShardParamsSchema: _lucid_evolution_lucid.TObject<{
    pollToken: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    stakingToken: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    indyAsset: _lucid_evolution_lucid.TObject<{
        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
    }>;
    stakingValHash: _lucid_evolution_lucid.TUnsafe<string>;
}>;
type PollShardParams = Data.Static<typeof PollShardParamsSchema>;
declare const PollShardParams: PollShardParams;
declare function castPollShardParams(params: PollShardParams): Data;

declare const mkPollManagerValidator: (params: PollManagerParams) => SpendingValidator;
declare const mkPollManagerValidatorFromSP: (params: PollManagerParamsSP) => SpendingValidator;
declare const mkPollShardValidator: (params: PollShardParams) => SpendingValidator;
declare const mkPollShardValidatorFromSP: (params: PollShardParamsSP) => SpendingValidator;

/**
 * Returns the collector ref script UTXO that was added to ref inputs.
 *
 * No need to return the TxBuilder since it's stateful object.
 */
declare function collectorFeeTx(fee: bigint, lucid: LucidEvolution, params: SystemParams, tx: TxBuilder, collectorOref: OutRef): Promise<UTxO>;

declare const CollectorRedeemerSchema: TSchema.Union<[TSchema.Literal<["Collect"]>, TSchema.Literal<["DistributeToStakers"]>, TSchema.Literal<["UpgradeVersion"]>]>;
type CollectorRedeemer = typeof CollectorRedeemerSchema.Type;
declare function serialiseCollectorRedeemer(r: CollectorRedeemer): string;

declare const ProtocolParamsSchema: TSchema.Struct<{
    proposalDeposit: TSchema.Integer;
    votingPeriod: TSchema.Integer;
    effectiveDelay: TSchema.Integer;
    expirationPeriod: TSchema.Integer;
    proposingPeriod: TSchema.Integer;
    totalShards: TSchema.Integer;
    minimumQuorum: TSchema.Integer;
    maxTreasuryLovelaceSpend: TSchema.Integer;
    maxTreasuryIndySpend: TSchema.Integer;
    cdpRedemptionRequiredSignature: TSchema.NullOr<TSchema.ByteArray>;
    electorate: TSchema.Integer;
    foundationMultisig: TSchema.Union<[TSchema.Struct<{
        Signature: TSchema.Struct<{
            keyHash: TSchema.ByteArray;
        }>;
    }>, TSchema.Struct<{
        AtLeast: TSchema.Struct<{
            required: TSchema.Integer;
            authSignatories: TSchema.Array<effect_Schema.SchemaClass<Data$1.Data, Data$1.Data, never>>;
        }>;
    }>]>;
}>;
type ProtocolParams = typeof ProtocolParamsSchema.Type;
declare const UpgradePathsSchema: TSchema.Struct<{
    upgradeId: TSchema.Integer;
    upgradePaths: TSchema.Array<TSchema.Tuple<[TSchema.ByteArray, TSchema.Struct<{
        upgradeSymbol: TSchema.ByteArray;
    }>]>>;
}>;
type UpgradePaths = typeof UpgradePathsSchema.Type;
declare const ProposeIAssetContentSchema: TSchema.Struct<{
    asset: TSchema.ByteArray;
    debtMintingFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    liquidationProcessingFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    stabilityPoolWithdrawalFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    redemptionReimbursementRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    redemptionProcessingFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
}>;
type ProposeAssetContent = typeof ProposeIAssetContentSchema.Type;
declare const AddCollateralAssetContentSchema: TSchema.Struct<{
    correspondingIAsset: TSchema.ByteArray;
    collateralAsset: TSchema.Struct<{
        currencySymbol: TSchema.ByteArray;
        tokenName: TSchema.ByteArray;
    }>;
    assetExtraDecimals: TSchema.Integer;
    assetPriceInfo: TSchema.Union<[TSchema.Struct<{
        Delisted: TSchema.Struct<{
            price: TSchema.Struct<{
                numerator: TSchema.Integer;
                denominator: TSchema.Integer;
            }>;
        }>;
    }>, TSchema.Struct<{
        OracleNft: TSchema.Struct<{
            currencySymbol: TSchema.ByteArray;
            tokenName: TSchema.ByteArray;
        }>;
    }>, TSchema.Struct<{
        DeferredValidation: TSchema.Struct<{
            feedValHash: TSchema.ByteArray;
        }>;
    }>]>;
    interestOracleNft: TSchema.Struct<{
        currencySymbol: TSchema.ByteArray;
        tokenName: TSchema.ByteArray;
    }>;
    redemptionRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    maintenanceRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    liquidationRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    minCollateralAmt: TSchema.Integer;
}>;
type AddCollateralAsssetContent = typeof AddCollateralAssetContentSchema.Type;
declare const ProposeStableswapPoolContentSchema: TSchema.Struct<{
    iasset: TSchema.ByteArray;
    collateralAsset: TSchema.Struct<{
        currencySymbol: TSchema.ByteArray;
        tokenName: TSchema.ByteArray;
    }>;
    collateralToIassetRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    mintingFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    redemptionFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    feeManager: TSchema.NullOr<TSchema.ByteArray>;
    minMintingAmount: TSchema.Integer;
    minRedemptionAmount: TSchema.Integer;
    stableswapValHash: TSchema.ByteArray;
}>;
type ProposeStableswapPoolContent = typeof ProposeStableswapPoolContentSchema.Type;
declare const ModifyStableswapPoolContentSchema: TSchema.Struct<{
    iasset: TSchema.ByteArray;
    collateralAsset: TSchema.Struct<{
        currencySymbol: TSchema.ByteArray;
        tokenName: TSchema.ByteArray;
    }>;
    newCollateralToIassetRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    newMintingFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    newRedemptionFeeRatio: TSchema.Struct<{
        numerator: TSchema.Integer;
        denominator: TSchema.Integer;
    }>;
    newMintingEnabled: TSchema.Boolean;
    newRedemptionEnabled: TSchema.Boolean;
    newFeeManager: TSchema.NullOr<TSchema.ByteArray>;
    newMinMintingAmount: TSchema.Integer;
    newMinRedemptionAmount: TSchema.Integer;
    newStableswapValHash: TSchema.ByteArray;
}>;
type ModifyStableswapPoolContent = typeof ModifyStableswapPoolContentSchema.Type;
declare const ProposalContentSchema: TSchema.Union<[TSchema.Struct<{
    ProposeIAsset: TSchema.Struct<{
        asset: TSchema.ByteArray;
        debtMintingFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        liquidationProcessingFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        stabilityPoolWithdrawalFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        redemptionReimbursementRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        redemptionProcessingFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
    }>;
}>, TSchema.Struct<{
    ModifyIAsset: TSchema.Struct<{
        asset: TSchema.ByteArray;
        newDebtMintingFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        newLiquidationProcessingFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        newStabilityPoolWithdrawalFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        newRedemptionReimbursementRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        newRedemptionProcessingFeeRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
    }>;
}>, TSchema.Struct<{
    AddCollateralAsset: TSchema.Struct<{
        correspondingIAsset: TSchema.ByteArray;
        collateralAsset: TSchema.Struct<{
            currencySymbol: TSchema.ByteArray;
            tokenName: TSchema.ByteArray;
        }>;
        assetExtraDecimals: TSchema.Integer;
        assetPriceInfo: TSchema.Union<[TSchema.Struct<{
            Delisted: TSchema.Struct<{
                price: TSchema.Struct<{
                    numerator: TSchema.Integer;
                    denominator: TSchema.Integer;
                }>;
            }>;
        }>, TSchema.Struct<{
            OracleNft: TSchema.Struct<{
                currencySymbol: TSchema.ByteArray;
                tokenName: TSchema.ByteArray;
            }>;
        }>, TSchema.Struct<{
            DeferredValidation: TSchema.Struct<{
                feedValHash: TSchema.ByteArray;
            }>;
        }>]>;
        interestOracleNft: TSchema.Struct<{
            currencySymbol: TSchema.ByteArray;
            tokenName: TSchema.ByteArray;
        }>;
        redemptionRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        maintenanceRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        liquidationRatio: TSchema.Struct<{
            numerator: TSchema.Integer;
            denominator: TSchema.Integer;
        }>;
        minCollateralAmt: TSchema.Integer;
    }>;
}>, TSchema.Struct<{
    UpdateCollateralAsset: T