@bithomp/xrpl-api 3.7.31 → 3.7.37

package/lib/src/types/ledger_entries.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/memos.d.ts

@@ -0,0 +1,12 @@
+export type Memo = {
+    Memo: {
+        MemoData?: string;
+        MemoType?: string;
+        MemoFormat?: string;
+    };
+};
+export type FormattedMemo = {
+    type?: string;
+    format?: string;
+    data?: string;
+};

package/lib/src/types/memos.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/mptokens.d.ts

@@ -0,0 +1,84 @@
+import { MPTokenIssuanceCreateFlags, MPTokenIssuanceSetFlags, MPTokenAuthorizeFlags } from "xrpl";
+import { FormattedBaseSpecification } from "./specification";
+import { TxGlobalFlagsKeysInterface } from "./global";
+export declare const MPTokenIssuanceFlagsKeys: {
+    locked: number;
+    canLock: MPTokenIssuanceCreateFlags;
+    requireAuth: MPTokenIssuanceCreateFlags;
+    canEscrow: MPTokenIssuanceCreateFlags;
+    canTrade: MPTokenIssuanceCreateFlags;
+    canTransfer: MPTokenIssuanceCreateFlags;
+    canClawback: MPTokenIssuanceCreateFlags;
+};
+export interface MPTokenIssuanceFlagsKeysInterface {
+    locked?: boolean;
+    canLock?: boolean;
+    requireAuth?: boolean;
+    canEscrow?: boolean;
+    canTrade?: boolean;
+    canTransfer?: boolean;
+    canClawback?: boolean;
+}
+export declare const MPTokenIssuanceCreateFlagsKeys: {
+    canLock: MPTokenIssuanceCreateFlags;
+    requireAuth: MPTokenIssuanceCreateFlags;
+    canEscrow: MPTokenIssuanceCreateFlags;
+    canTrade: MPTokenIssuanceCreateFlags;
+    canTransfer: MPTokenIssuanceCreateFlags;
+    canClawback: MPTokenIssuanceCreateFlags;
+};
+export declare function getMPTokenIssuanceCreateFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface MPTokenIssuanceCreateFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    canLock?: boolean;
+    requireAuth?: boolean;
+    canEscrow?: boolean;
+    canTrade?: boolean;
+    canTransfer?: boolean;
+    canClawback?: boolean;
+}
+export declare const MPTokenIssuanceSetFlagsKeys: {
+    lock: MPTokenIssuanceSetFlags;
+    unlock: MPTokenIssuanceSetFlags;
+};
+export declare function getMPTokenIssuanceSetFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface MPTokenIssuanceSetFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    lock?: boolean;
+    unlock?: boolean;
+}
+export declare const MPTokenAuthorizeFlagsKeys: {
+    unauthorize: MPTokenAuthorizeFlags;
+};
+export declare function getMPTokenAuthorizeFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface MPTokenAuthorizeFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    unauthorize?: boolean;
+}
+export type FormattedMPTokenAuthorizeSpecification = {
+    flags?: MPTokenAuthorizeFlagsKeysInterface;
+    holder?: string;
+    mptIssuanceID?: string;
+} & FormattedBaseSpecification;
+export type FormattedMPTokenIssuanceCreateSpecification = {
+    issuer?: string;
+    sequence?: number;
+    scale?: number;
+    flags?: MPTokenIssuanceCreateFlagsKeysInterface;
+    metadata?: string | null;
+    maximumAmount?: string;
+    transferFee?: number;
+} & FormattedBaseSpecification;
+export type FormattedMPTokenIssuanceDestroySpecification = {
+    mptIssuanceID?: string;
+} & FormattedBaseSpecification;
+export type FormattedMPTokenIssuanceSetSpecification = {
+    flags?: MPTokenIssuanceSetFlagsKeysInterface;
+    holder?: string;
+    mptIssuanceID?: string;
+} & FormattedBaseSpecification;
+export declare const MPTokenFlagsKeys: {
+    locked: number;
+    authorized: number;
+};
+export interface MPTokenFlagsKeysInterface {
+    locked?: boolean;
+    authorized?: boolean;
+}

package/lib/src/types/mptokens.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MPTokenFlagsKeys = exports.MPTokenAuthorizeFlagsKeys = exports.MPTokenIssuanceSetFlagsKeys = exports.MPTokenIssuanceCreateFlagsKeys = exports.MPTokenIssuanceFlagsKeys = void 0;
+exports.getMPTokenIssuanceCreateFlagsKeys = getMPTokenIssuanceCreateFlagsKeys;
+exports.getMPTokenIssuanceSetFlagsKeys = getMPTokenIssuanceSetFlagsKeys;
+exports.getMPTokenAuthorizeFlagsKeys = getMPTokenAuthorizeFlagsKeys;
+const xrpl_1 = require("xrpl");
+const global_1 = require("./global");
+const common_1 = require("../common");
+exports.MPTokenIssuanceFlagsKeys = {
+    locked: 0x00000001,
+    canLock: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanLock,
+    requireAuth: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTRequireAuth,
+    canEscrow: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanEscrow,
+    canTrade: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanTrade,
+    canTransfer: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanTransfer,
+    canClawback: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanClawback,
+};
+exports.MPTokenIssuanceCreateFlagsKeys = {
+    canLock: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanLock,
+    requireAuth: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTRequireAuth,
+    canEscrow: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanEscrow,
+    canTrade: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanTrade,
+    canTransfer: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanTransfer,
+    canClawback: xrpl_1.MPTokenIssuanceCreateFlags.tfMPTCanClawback,
+};
+const nativeCurrencyMPTokenIssuanceCreateFlags = {};
+function getMPTokenIssuanceCreateFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyMPTokenIssuanceCreateFlags[nativeCurrency]) {
+        nativeCurrencyMPTokenIssuanceCreateFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.MPTokenIssuanceCreateFlagsKeys,
+        };
+    }
+    return nativeCurrencyMPTokenIssuanceCreateFlags[nativeCurrency];
+}
+exports.MPTokenIssuanceSetFlagsKeys = {
+    lock: xrpl_1.MPTokenIssuanceSetFlags.tfMPTLock,
+    unlock: xrpl_1.MPTokenIssuanceSetFlags.tfMPTUnlock,
+};
+const nativeCurrencyMPTokenIssuanceSetFlags = {};
+function getMPTokenIssuanceSetFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyMPTokenIssuanceSetFlags[nativeCurrency]) {
+        nativeCurrencyMPTokenIssuanceSetFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.MPTokenIssuanceSetFlagsKeys,
+        };
+    }
+    return nativeCurrencyMPTokenIssuanceSetFlags[nativeCurrency];
+}
+exports.MPTokenAuthorizeFlagsKeys = {
+    unauthorize: xrpl_1.MPTokenAuthorizeFlags.tfMPTUnauthorize,
+};
+const nativeCurrencyMPTokenAuthorizeFlags = {};
+function getMPTokenAuthorizeFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyMPTokenAuthorizeFlags[nativeCurrency]) {
+        nativeCurrencyMPTokenAuthorizeFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.MPTokenAuthorizeFlagsKeys,
+        };
+    }
+    return nativeCurrencyMPTokenAuthorizeFlags[nativeCurrency];
+}
+exports.MPTokenFlagsKeys = {
+    locked: 0x00000001,
+    authorized: 0x00000002,
+};

package/lib/src/types/nftokens.d.ts

@@ -0,0 +1,62 @@
+import { NFTokenMintFlags, NFTokenCreateOfferFlags } from "xrpl";
+import { FormattedBaseSpecification } from "./specification";
+import { Amount } from "./amounts";
+import { FormattedSourceAddress, FormattedDestinationAddress } from "./account";
+import { TxGlobalFlagsKeysInterface } from "./global";
+export declare const NFTokenFlagsKeys: {
+    burnable: NFTokenMintFlags;
+    onlyXRP: NFTokenMintFlags;
+    trustLine: NFTokenMintFlags;
+    transferable: NFTokenMintFlags;
+    mutable: NFTokenMintFlags;
+};
+export declare function getNFTokenMintFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface NFTokenFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    burnable?: boolean;
+    onlyXRP?: boolean;
+    trustLine?: boolean;
+    transferable?: boolean;
+    mutable?: boolean;
+}
+export declare const NFTokenOfferFlagsKeys: {
+    sellToken: NFTokenCreateOfferFlags;
+};
+export declare function getNFTokenOfferCreateFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface NFTokenOfferFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    sellToken?: boolean;
+}
+export type FormattedNFTokenBurnSpecification = {
+    nftokenID: string;
+} & FormattedBaseSpecification;
+export type FormattedNFTokenMintSpecification = {
+    nftokenTaxon: number;
+    issuer?: string;
+    transferFee?: number;
+    uri?: string | null;
+    flags?: NFTokenFlagsKeysInterface;
+    amount?: Amount;
+    destination?: FormattedDestinationAddress;
+    expiration?: number;
+} & FormattedBaseSpecification;
+export type FormattedNFTokenModifySpecification = {
+    nftokenID: string;
+    owner?: string;
+    uri?: string | null;
+} & FormattedBaseSpecification;
+export type FormattedNFTokenCancelOfferSpecification = {
+    nftokenOffers: string[];
+} & FormattedBaseSpecification;
+export type FormattedNFTokenCreateOfferSpecification = {
+    nftokenID: string;
+    amount: Amount;
+    owner?: string;
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+    expiration?: number;
+    flags?: NFTokenOfferFlagsKeysInterface;
+} & FormattedBaseSpecification;
+export type FormattedNFTokenAcceptOfferSpecification = {
+    nftokenSellOffer?: string;
+    nftokenBuyOffer?: string;
+    nftokenBrokerFee?: Amount;
+} & FormattedBaseSpecification;

package/lib/src/types/nftokens.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTokenOfferFlagsKeys = exports.NFTokenFlagsKeys = void 0;
+exports.getNFTokenMintFlagsKeys = getNFTokenMintFlagsKeys;
+exports.getNFTokenOfferCreateFlagsKeys = getNFTokenOfferCreateFlagsKeys;
+const xrpl_1 = require("xrpl");
+const global_1 = require("./global");
+const common_1 = require("../common");
+exports.NFTokenFlagsKeys = {
+    burnable: xrpl_1.NFTokenMintFlags.tfBurnable,
+    onlyXRP: xrpl_1.NFTokenMintFlags.tfOnlyXRP,
+    trustLine: xrpl_1.NFTokenMintFlags.tfTrustLine,
+    transferable: xrpl_1.NFTokenMintFlags.tfTransferable,
+    mutable: xrpl_1.NFTokenMintFlags.tfMutable,
+};
+const nativeCurrencyNFTokenMintFlags = {};
+function getNFTokenMintFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyNFTokenMintFlags[nativeCurrency]) {
+        nativeCurrencyNFTokenMintFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.NFTokenFlagsKeys,
+        };
+    }
+    return nativeCurrencyNFTokenMintFlags[nativeCurrency];
+}
+exports.NFTokenOfferFlagsKeys = {
+    sellToken: xrpl_1.NFTokenCreateOfferFlags.tfSellNFToken,
+};
+const nativeCurrencyNFTokenOfferCreateFlags = {};
+function getNFTokenOfferCreateFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyNFTokenOfferCreateFlags[nativeCurrency]) {
+        nativeCurrencyNFTokenOfferCreateFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.NFTokenOfferFlagsKeys,
+        };
+    }
+    return nativeCurrencyNFTokenOfferCreateFlags[nativeCurrency];
+}

package/lib/src/types/offers.d.ts

@@ -0,0 +1,46 @@
+import { LedgerEntry, OfferCreateFlags } from "xrpl";
+import { FormattedBaseSpecification } from "./specification";
+import { IssuedCurrencyAmount } from "./amounts";
+import { TxGlobalFlagsKeysInterface } from "./global";
+export declare const OfferCreateFlagsKeys: {
+    passive: OfferCreateFlags;
+    immediateOrCancel: OfferCreateFlags;
+    fillOrKill: OfferCreateFlags;
+    sell: OfferCreateFlags;
+    hybrid: OfferCreateFlags;
+};
+export declare function getOfferCreateFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface OfferCreateFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    passive: boolean;
+    immediateOrCancel: boolean;
+    fillOrKill: boolean;
+    sell: boolean;
+    hybrid: boolean;
+}
+export declare const OfferFlagsKeys: {
+    passive: LedgerEntry.OfferFlags;
+    sell: LedgerEntry.OfferFlags;
+    hybrid: LedgerEntry.OfferFlags;
+};
+export interface OfferFlagsKeysInterface {
+    passive: boolean;
+    sell: boolean;
+    hybrid: boolean;
+}
+export type FormattedOfferCancelSpecification = {
+    orderSequence: number;
+} & FormattedBaseSpecification;
+export type FormattedOfferCreateSpecification = {
+    flags: OfferCreateFlagsKeysInterface;
+    takerGets: IssuedCurrencyAmount;
+    takerPays: IssuedCurrencyAmount;
+    expirationTime?: string;
+    orderToReplace?: number;
+    domainID?: string;
+    direction: string;
+    immediateOrCancel?: boolean;
+    fillOrKill?: boolean;
+    passive?: boolean;
+    quantity: IssuedCurrencyAmount;
+    totalPrice: IssuedCurrencyAmount;
+} & FormattedBaseSpecification;

package/lib/src/types/offers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfferFlagsKeys = exports.OfferCreateFlagsKeys = void 0;
+exports.getOfferCreateFlagsKeys = getOfferCreateFlagsKeys;
+const xrpl_1 = require("xrpl");
+const { OfferFlags } = xrpl_1.LedgerEntry;
+const global_1 = require("./global");
+const common_1 = require("../common");
+exports.OfferCreateFlagsKeys = {
+    passive: xrpl_1.OfferCreateFlags.tfPassive,
+    immediateOrCancel: xrpl_1.OfferCreateFlags.tfImmediateOrCancel,
+    fillOrKill: xrpl_1.OfferCreateFlags.tfFillOrKill,
+    sell: xrpl_1.OfferCreateFlags.tfSell,
+    hybrid: xrpl_1.OfferCreateFlags.tfHybrid,
+};
+const nativeCurrencyOfferCreateFlags = {};
+function getOfferCreateFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyOfferCreateFlags[nativeCurrency]) {
+        nativeCurrencyOfferCreateFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.OfferCreateFlagsKeys,
+        };
+    }
+    return nativeCurrencyOfferCreateFlags[nativeCurrency];
+}
+exports.OfferFlagsKeys = {
+    passive: OfferFlags.lsfPassive,
+    sell: OfferFlags.lsfSell,
+    hybrid: OfferFlags.lsfHybrid,
+};

package/lib/src/types/oracle.d.ts

@@ -0,0 +1,19 @@
+import { FormattedBaseSpecification } from "./specification";
+export interface FormattedOraclePriceDataSeriesInterface {
+    baseAsset: string;
+    quoteAsset: string;
+    assetPrice?: string;
+    scale?: number;
+    originalAssetPriceChange?: string;
+}
+export type FormattedOracleSetSpecification = {
+    oracleDocumentID: number;
+    provider?: string;
+    uri?: string | null;
+    assetClass?: string;
+    lastUpdateTime: number;
+    priceDataSeries?: FormattedOraclePriceDataSeriesInterface[];
+} & FormattedBaseSpecification;
+export type FormattedOracleDeleteSpecification = {
+    oracleDocumentID: number;
+} & FormattedBaseSpecification;

package/lib/src/types/oracle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/outcome.d.ts

@@ -0,0 +1,22 @@
+import { FormattedIssuedCurrencyAmount, FormattedIssuedMPTAmount } from "./amounts";
+import { LockedBalanceChanges } from "../parse/outcome/locked_balance_changes";
+import { BalanceChanges } from "../parse/outcome/balance_changes";
+export type Outcome = {
+    result?: string;
+    ledgerIndex?: number;
+    ledgerVersion?: number;
+    indexInLedger?: number;
+    fee?: string;
+    balanceChanges?: BalanceChanges;
+    lockedBalanceChanges?: LockedBalanceChanges;
+    orderbookChanges?: object;
+    channelChanges?: object;
+    nftokenChanges?: object;
+    nftokenOfferChanges?: object;
+    uritokenChanges?: object;
+    uritokenSellOfferChanges?: object;
+    affectedObjects?: object;
+    ammChanges?: object;
+    deliveredAmount?: FormattedIssuedCurrencyAmount | FormattedIssuedMPTAmount;
+    timestamp?: string;
+};

package/lib/src/types/outcome.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/payment_channels.d.ts

@@ -0,0 +1,23 @@
+import { FormattedBaseSpecification } from "./specification";
+import { FormattedAmount } from "./amounts";
+import { FormattedSourceAddress, FormattedDestinationAddress } from "./account";
+export type FormattedPaymentChannelClaimSpecification = {
+    channel: string;
+    balance?: FormattedAmount;
+    amount?: FormattedAmount;
+    renew?: boolean;
+    close?: boolean;
+} & FormattedBaseSpecification;
+export type FormattedPaymentChannelCreateSpecification = {
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+    amount?: FormattedAmount;
+    settleDelay: number;
+    publicKey?: string;
+    cancelAfter?: string | number;
+} & FormattedBaseSpecification;
+export type FormattedPaymentChannelFundSpecification = {
+    channel: string;
+    amount?: FormattedAmount;
+    expiration?: string | number;
+} & FormattedBaseSpecification;

package/lib/src/types/payment_channels.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/payments.d.ts

@@ -0,0 +1,24 @@
+import { PaymentFlags } from "xrpl";
+import { FormattedBaseSpecification } from "./specification";
+import { FormattedSourceAddress, FormattedDestinationAddress } from "./account";
+import { TxGlobalFlagsKeysInterface } from "./global";
+export declare const PaymentFlagsKeys: {
+    noRippleDirect: PaymentFlags;
+    partialPayment: PaymentFlags;
+    limitQuality: PaymentFlags;
+};
+export declare function getPaymentFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface PaymentKeysInterface extends TxGlobalFlagsKeysInterface {
+    noRippleDirect?: boolean;
+    partialPayment?: boolean;
+    limitQuality?: boolean;
+}
+export type FormattedPaymentSpecification = {
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+    invoiceID?: string;
+    paths?: string;
+    allowPartialPayment?: boolean;
+    noDirectRipple?: boolean;
+    limitQuality?: boolean;
+} & FormattedBaseSpecification;

package/lib/src/types/payments.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentFlagsKeys = void 0;
+exports.getPaymentFlagsKeys = getPaymentFlagsKeys;
+const xrpl_1 = require("xrpl");
+const global_1 = require("./global");
+const common_1 = require("../common");
+exports.PaymentFlagsKeys = {
+    noRippleDirect: xrpl_1.PaymentFlags.tfNoRippleDirect,
+    partialPayment: xrpl_1.PaymentFlags.tfPartialPayment,
+    limitQuality: xrpl_1.PaymentFlags.tfLimitQuality,
+};
+const nativeCurrencyPaymentFlags = {};
+function getPaymentFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyPaymentFlags[nativeCurrency]) {
+        nativeCurrencyPaymentFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.PaymentFlagsKeys,
+        };
+    }
+    return nativeCurrencyPaymentFlags[nativeCurrency];
+}

package/lib/src/types/queue_data.d.ts

@@ -0,0 +1,15 @@
+export interface QueueTransaction {
+    auth_change: boolean;
+    fee: string;
+    fee_level: string;
+    max_spend_drops: string;
+    seq: number;
+}
+export interface QueueData {
+    txn_count: number;
+    auth_change_queued?: boolean;
+    lowest_sequence?: number;
+    highest_sequence?: number;
+    max_spend_drops_total?: string;
+    transactions?: QueueTransaction[];
+}

package/lib/src/types/queue_data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/remarks.d.ts

@@ -0,0 +1,24 @@
+import { SetRemarksFlags } from "../models/transactions/SetRemarks";
+import { FormattedBaseSpecification } from "./specification";
+export declare const RemarksFlagsKeys: {
+    immutable: SetRemarksFlags;
+};
+export interface RemarksFlagsKeysInterface {
+    immutable?: boolean;
+}
+export type Remark = {
+    Remark: {
+        RemarkName?: string;
+        RemarkValue?: string;
+        Flags?: number;
+    };
+};
+export type FormattedRemark = {
+    name?: string;
+    value?: string;
+    flags?: RemarksFlagsKeysInterface;
+};
+export type FormattedSetRemarksSpecification = {
+    ObjectID?: string;
+    Remarks?: FormattedRemark[];
+} & FormattedBaseSpecification;

package/lib/src/types/remarks.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemarksFlagsKeys = void 0;
+exports.RemarksFlagsKeys = {
+    immutable: 1,
+};

package/lib/src/types/remits.d.ts

@@ -0,0 +1,15 @@
+import { FormattedBaseSpecification } from "./specification";
+import { Amount } from "./amounts";
+import { URITokenFlagsKeysInterface } from "./uritokens";
+export type FormattedRemitsSpecification = {
+    amounts?: Amount[];
+    uritokenIDs?: string[];
+    uritokenMint?: {
+        uri: string;
+        flags?: URITokenFlagsKeysInterface;
+        digest?: string;
+    };
+    blob?: string;
+    inform?: string;
+    invoiceID?: string;
+} & FormattedBaseSpecification;

package/lib/src/types/remits.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/settings.d.ts

@@ -0,0 +1,27 @@
+import { FormattedBaseSpecification } from "./specification";
+import { FormattedTransactionSigner } from "./signers";
+export type FormattedSettingsSpecification = {
+    defaultRipple?: boolean;
+    depositAuth?: boolean;
+    disableMasterKey?: boolean;
+    disallowIncomingXRP?: boolean;
+    disallowIncomingNFTokenOffer?: boolean;
+    disallowIncomingCheck?: boolean;
+    disallowIncomingPayChan?: boolean;
+    disallowIncomingTrustline?: boolean;
+    domain?: string;
+    emailHash?: string | null;
+    enableTransactionIDTracking?: boolean;
+    globalFreeze?: boolean;
+    messageKey?: string;
+    noFreeze?: boolean;
+    passwordSpent?: boolean;
+    regularKey?: string;
+    requireAuthorization?: boolean;
+    requireDestinationTag?: boolean;
+    signers?: FormattedTransactionSigner[] | null;
+    transferRate?: number | null;
+    tickSize?: number;
+    nftokenMinter?: string;
+    walletLocator?: string | null;
+} & FormattedBaseSpecification;

package/lib/src/types/settings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/signers.d.ts

@@ -0,0 +1,22 @@
+export interface SignerEntry {
+    SignerEntry: {
+        Account: string;
+        SignerWeight: number;
+    };
+}
+export interface FormattedSigner {
+    address: string;
+    weight: number;
+}
+export interface TransactionSigner {
+    Signer: {
+        SigningPubKey: string;
+        TxnSignature: string;
+        Account?: string;
+    };
+}
+export interface FormattedTransactionSigner {
+    address: string;
+    signingPubKey?: string;
+    txnSignature?: string;
+}

package/lib/src/types/signers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/specification.d.ts

@@ -0,0 +1,14 @@
+import { FormattedSourceAddress, FormattedSignerRegularKey } from "./account";
+import { FormattedEmitDetails } from "./emit_details";
+import { FormattedMemo } from "./memos";
+import { FormattedTransactionSigner } from "./signers";
+import { TxGlobalFlagsKeysInterface } from "./global";
+export type FormattedBaseSpecification = {
+    source?: FormattedSourceAddress;
+    signers?: FormattedTransactionSigner[];
+    signer?: FormattedSignerRegularKey;
+    delegate?: FormattedSignerRegularKey;
+    emittedDetails?: FormattedEmitDetails;
+    flags?: TxGlobalFlagsKeysInterface;
+    memos?: FormattedMemo[];
+};

package/lib/src/types/specification.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/tickets.d.ts

@@ -0,0 +1,4 @@
+import { FormattedBaseSpecification } from "./specification";
+export type FormattedTicketCreateSpecification = {
+    ticketCount: number;
+} & FormattedBaseSpecification;

package/lib/src/types/tickets.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });