pshenmic-dpp 1.1.2-dev.8 → 2.0.0-dev.1

package/dist/src/dpp/structs/TokenConfiguration/TokenConfigurationLocalization.d.ts

@@ -0,0 +1,15 @@
+import { TokenConfigurationLocalizationNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenConfigurationLocalizationJson } from '../../types.js';
+export declare class TokenConfigurationLocalizationWASM {
+    /** @private **/
+    _rawTokenConfigurationLocalization: TokenConfigurationLocalizationNAPI;
+    constructor(shouldCapitalize: boolean, singularForm: string, pluralForm: string);
+    get shouldCapitalize(): boolean;
+    set shouldCapitalize(shouldCapitalize: boolean);
+    get pluralForm(): string;
+    set pluralForm(pluralForm: string);
+    get singularForm(): string;
+    set singularForm(singularForm: string);
+    toJSON(): TokenConfigurationLocalizationJson;
+    static createFromRawInstance(rawInstance: TokenConfigurationLocalizationNAPI): TokenConfigurationLocalizationWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenConfigurationLocalization.js

@@ -0,0 +1,34 @@
+import { dppProvider } from '../../provider.js';
+export class TokenConfigurationLocalizationWASM {
+    /** @private **/
+    _rawTokenConfigurationLocalization;
+    constructor(shouldCapitalize, singularForm, pluralForm) {
+        this._rawTokenConfigurationLocalization = new dppProvider.dpp.TokenConfigurationLocalizationNAPI(shouldCapitalize, singularForm, pluralForm);
+    }
+    get shouldCapitalize() {
+        return this._rawTokenConfigurationLocalization.shouldCapitalize;
+    }
+    set shouldCapitalize(shouldCapitalize) {
+        this._rawTokenConfigurationLocalization.shouldCapitalize = shouldCapitalize;
+    }
+    get pluralForm() {
+        return this._rawTokenConfigurationLocalization.pluralForm;
+    }
+    set pluralForm(pluralForm) {
+        this._rawTokenConfigurationLocalization.pluralForm = pluralForm;
+    }
+    get singularForm() {
+        return this._rawTokenConfigurationLocalization.singularForm;
+    }
+    set singularForm(singularForm) {
+        this._rawTokenConfigurationLocalization.singularForm = singularForm;
+    }
+    toJSON() {
+        return this._rawTokenConfigurationLocalization.toJSON();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenConfigurationLocalization = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRecipient.d.ts

@@ -0,0 +1,14 @@
+import { TokenDistributionRecipientNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenDistributionRecipientWASM {
+    /** @private **/
+    _rawTokenDistributionRecipient: TokenDistributionRecipientNAPI;
+    private constructor();
+    getType(): string;
+    getValue(): IdentifierWASM | undefined;
+    static ContractOwner(): TokenDistributionRecipientWASM;
+    static Identity(id: IdentifierLike): TokenDistributionRecipientWASM;
+    static EvonodesByParticipation(): TokenDistributionRecipientWASM;
+    static createFromRawInstance(rawInstance: TokenDistributionRecipientNAPI): TokenDistributionRecipientWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRecipient.js

@@ -0,0 +1,31 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class TokenDistributionRecipientWASM {
+    /** @private **/
+    _rawTokenDistributionRecipient;
+    constructor(rawInstance) {
+        this._rawTokenDistributionRecipient = rawInstance;
+    }
+    getType() {
+        return this._rawTokenDistributionRecipient.getType();
+    }
+    getValue() {
+        const value = this._rawTokenDistributionRecipient.getValue();
+        if (value !== undefined) {
+            return IdentifierWASM.createFromRawInstance(value);
+        }
+    }
+    static ContractOwner() {
+        return new TokenDistributionRecipientWASM(dppProvider.dpp.TokenDistributionRecipientNAPI.ContractOwner());
+    }
+    static Identity(id) {
+        return new TokenDistributionRecipientWASM(dppProvider.dpp.TokenDistributionRecipientNAPI.Identity(prepareIdentifierValue(id)));
+    }
+    static EvonodesByParticipation() {
+        return new TokenDistributionRecipientWASM(dppProvider.dpp.TokenDistributionRecipientNAPI.EvonodesByParticipation());
+    }
+    static createFromRawInstance(rawInstance) {
+        return new TokenDistributionRecipientWASM(rawInstance);
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRules.d.ts

@@ -0,0 +1,28 @@
+import { TokenDistributionRulesNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenPerpetualDistributionWASM } from './TokenPerpetualDistribution.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { TokenPreProgrammedDistributionWASM } from './TokenPreProgrammedDistribution.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenDistributionRulesWASM {
+    /** @private **/
+    _rawTokenDistributionRules: TokenDistributionRulesNAPI;
+    constructor(perpetualDistributionRules: ChangeControlRulesWASM, newTokensDestinationIdentityRules: ChangeControlRulesWASM, mintingAllowChoosingDestination: boolean, mintingAllowChoosingDestinationRules: ChangeControlRulesWASM, changeDirectPurchasePricingRules: ChangeControlRulesWASM, perpetualDistribution?: TokenPerpetualDistributionWASM, preProgrammedDistribution?: TokenPreProgrammedDistributionWASM, newTokensDestinationIdentity?: IdentifierLike);
+    get perpetualDistribution(): TokenPerpetualDistributionWASM | undefined;
+    set perpetualDistribution(perpetualDistribution: TokenPerpetualDistributionWASM);
+    get perpetualDistributionRules(): ChangeControlRulesWASM;
+    set perpetualDistributionRules(rules: ChangeControlRulesWASM);
+    get preProgrammedDistribution(): TokenPreProgrammedDistributionWASM | undefined;
+    set preProgrammedDistribution(preProgrammedDistribution: TokenPreProgrammedDistributionWASM);
+    get newTokenDestinationIdentity(): IdentifierWASM | undefined;
+    set newTokenDestinationIdentity(destinationIdentity: IdentifierLike | undefined);
+    get newTokenDestinationIdentityRules(): ChangeControlRulesWASM;
+    set newTokenDestinationIdentityRules(rules: ChangeControlRulesWASM);
+    get mintingAllowChoosingDestination(): boolean;
+    set mintingAllowChoosingDestination(mintingAllowChoosingDestination: boolean);
+    get mintingAllowChoosingDestinationRules(): ChangeControlRulesWASM;
+    set mintingAllowChoosingDestinationRules(mintingAllowChoosingDestinationRules: ChangeControlRulesWASM);
+    get changeDirectPurchasePricingRules(): ChangeControlRulesWASM;
+    set changeDirectPurchasePricingRules(changeDirectPurchasePricingRules: ChangeControlRulesWASM);
+    static createFromRawInstance(rawInstance: TokenDistributionRulesNAPI): TokenDistributionRulesWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRules.js

@@ -0,0 +1,75 @@
+import { TokenPerpetualDistributionWASM } from './TokenPerpetualDistribution.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { TokenPreProgrammedDistributionWASM } from './TokenPreProgrammedDistribution.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class TokenDistributionRulesWASM {
+    /** @private **/
+    _rawTokenDistributionRules;
+    constructor(perpetualDistributionRules, newTokensDestinationIdentityRules, mintingAllowChoosingDestination, mintingAllowChoosingDestinationRules, changeDirectPurchasePricingRules, perpetualDistribution, preProgrammedDistribution, newTokensDestinationIdentity) {
+        this._rawTokenDistributionRules = new dppProvider.dpp.TokenDistributionRulesNAPI(perpetualDistribution?._rawTokenPerpetualDistribution, perpetualDistributionRules._rawChangeControlRules, preProgrammedDistribution?._rawTokenPreProgrammedDistribution, newTokensDestinationIdentity != null ? prepareIdentifierValue(newTokensDestinationIdentity) : undefined, newTokensDestinationIdentityRules._rawChangeControlRules, mintingAllowChoosingDestination, mintingAllowChoosingDestinationRules?._rawChangeControlRules, changeDirectPurchasePricingRules?._rawChangeControlRules);
+    }
+    get perpetualDistribution() {
+        const dist = this._rawTokenDistributionRules.perpetualDistribution;
+        if (dist != null) {
+            return TokenPerpetualDistributionWASM.createFromRawInstance(dist);
+        }
+    }
+    set perpetualDistribution(perpetualDistribution) {
+        this._rawTokenDistributionRules.perpetualDistribution = perpetualDistribution._rawTokenPerpetualDistribution;
+    }
+    get perpetualDistributionRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.perpetualDistributionRules);
+    }
+    set perpetualDistributionRules(rules) {
+        this._rawTokenDistributionRules.perpetualDistributionRules = rules._rawChangeControlRules;
+    }
+    get preProgrammedDistribution() {
+        const dist = this._rawTokenDistributionRules.preProgrammedDistribution;
+        if (dist != null) {
+            return TokenPreProgrammedDistributionWASM.createFromRawInstance(dist);
+        }
+    }
+    set preProgrammedDistribution(preProgrammedDistribution) {
+        this._rawTokenDistributionRules.preProgrammedDistribution = preProgrammedDistribution._rawTokenPreProgrammedDistribution;
+    }
+    get newTokenDestinationIdentity() {
+        const destination = this._rawTokenDistributionRules.newTokenDestinationIdentity;
+        if (destination != null) {
+            return IdentifierWASM.createFromRawInstance(destination);
+        }
+    }
+    set newTokenDestinationIdentity(destinationIdentity) {
+        this._rawTokenDistributionRules.newTokenDestinationIdentity = destinationIdentity != null ? prepareIdentifierValue(destinationIdentity) : undefined;
+    }
+    get newTokenDestinationIdentityRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.newTokenDestinationIdentityRules);
+    }
+    set newTokenDestinationIdentityRules(rules) {
+        this._rawTokenDistributionRules.newTokenDestinationIdentityRules = rules._rawChangeControlRules;
+    }
+    get mintingAllowChoosingDestination() {
+        return this._rawTokenDistributionRules.mintingAllowChoosingDestination;
+    }
+    set mintingAllowChoosingDestination(mintingAllowChoosingDestination) {
+        this._rawTokenDistributionRules.mintingAllowChoosingDestination = mintingAllowChoosingDestination;
+    }
+    get mintingAllowChoosingDestinationRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.mintingAllowChoosingDestinationRules);
+    }
+    set mintingAllowChoosingDestinationRules(mintingAllowChoosingDestinationRules) {
+        this._rawTokenDistributionRules.mintingAllowChoosingDestinationRules = mintingAllowChoosingDestinationRules._rawChangeControlRules;
+    }
+    get changeDirectPurchasePricingRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.changeDirectPurchasePricingRules);
+    }
+    set changeDirectPurchasePricingRules(changeDirectPurchasePricingRules) {
+        this._rawTokenDistributionRules.changeDirectPurchasePricingRules = changeDirectPurchasePricingRules._rawChangeControlRules;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenDistributionRules = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenKeepsHistoryRules.d.ts

@@ -0,0 +1,19 @@
+import { TokenKeepsHistoryRulesNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TokenKeepsHistoryRulesWASM {
+    /** @private **/
+    _rawTokenKeepsHistoryRules: TokenKeepsHistoryRulesNAPI;
+    constructor(keepsTransferHistory: boolean, keepsFreezingHistory: boolean, keepsMintingHistory: boolean, keepsBurningHistory: boolean, keepsDirectPricingHistory: boolean, keepsDirectPurchaseHistory: boolean);
+    get keepsTransferHistory(): boolean;
+    set keepsTransferHistory(keepsTransferHistory: boolean);
+    get keepsFreezingHistory(): boolean;
+    set keepsFreezingHistory(keepsFreezingHistory: boolean);
+    get keepsMintingHistory(): boolean;
+    set keepsMintingHistory(keepsMintingHistory: boolean);
+    get keepsBurningHistory(): boolean;
+    set keepsBurningHistory(keepsBurningHistory: boolean);
+    get keepsDirectPricingHistory(): boolean;
+    set keepsDirectPricingHistory(keepsDirectPricingHistory: boolean);
+    get keepsDirectPurchaseHistory(): boolean;
+    set keepsDirectPurchaseHistory(keepsDirectPurchaseHistory: boolean);
+    static createFromRawInstance(rawInstance: TokenKeepsHistoryRulesNAPI): TokenKeepsHistoryRulesWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenKeepsHistoryRules.js

@@ -0,0 +1,49 @@
+import { dppProvider } from '../../provider.js';
+export class TokenKeepsHistoryRulesWASM {
+    /** @private **/
+    _rawTokenKeepsHistoryRules;
+    constructor(keepsTransferHistory, keepsFreezingHistory, keepsMintingHistory, keepsBurningHistory, keepsDirectPricingHistory, keepsDirectPurchaseHistory) {
+        this._rawTokenKeepsHistoryRules = new dppProvider.dpp.TokenKeepsHistoryRulesNAPI(keepsTransferHistory, keepsFreezingHistory, keepsMintingHistory, keepsBurningHistory, keepsDirectPricingHistory, keepsDirectPurchaseHistory);
+    }
+    get keepsTransferHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsTransferHistory;
+    }
+    set keepsTransferHistory(keepsTransferHistory) {
+        this._rawTokenKeepsHistoryRules.keepsTransferHistory = keepsTransferHistory;
+    }
+    get keepsFreezingHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsFreezingHistory;
+    }
+    set keepsFreezingHistory(keepsFreezingHistory) {
+        this._rawTokenKeepsHistoryRules.keepsFreezingHistory = keepsFreezingHistory;
+    }
+    get keepsMintingHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsMintingHistory;
+    }
+    set keepsMintingHistory(keepsMintingHistory) {
+        this._rawTokenKeepsHistoryRules.keepsMintingHistory = keepsMintingHistory;
+    }
+    get keepsBurningHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsBurningHistory;
+    }
+    set keepsBurningHistory(keepsBurningHistory) {
+        this._rawTokenKeepsHistoryRules.keepsBurningHistory = keepsBurningHistory;
+    }
+    get keepsDirectPricingHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsDirectPricingHistory;
+    }
+    set keepsDirectPricingHistory(keepsDirectPricingHistory) {
+        this._rawTokenKeepsHistoryRules.keepsDirectPricingHistory = keepsDirectPricingHistory;
+    }
+    get keepsDirectPurchaseHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsDirectPurchaseHistory;
+    }
+    set keepsDirectPurchaseHistory(keepsDirectPurchaseHistory) {
+        this._rawTokenKeepsHistoryRules.keepsDirectPurchaseHistory = keepsDirectPurchaseHistory;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenKeepsHistoryRules = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenMarketplaceRules.d.ts

@@ -0,0 +1,13 @@
+import { TokenMarketplaceRulesNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenTradeModeWASM } from './TokenTradeMode.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+export declare class TokenMarketplaceRulesWASM {
+    /** @private **/
+    _rawTokenMarketplaceRules: TokenMarketplaceRulesNAPI;
+    constructor(tradeMode: TokenTradeModeWASM, tradeModeChangeRules: ChangeControlRulesWASM);
+    get tradeMode(): TokenTradeModeWASM;
+    set tradeMode(value: TokenTradeModeWASM);
+    get tradeModeChangeRules(): ChangeControlRulesWASM;
+    set tradeModeChangeRules(value: ChangeControlRulesWASM);
+    static createFromRawInstance(rawInstance: TokenMarketplaceRulesNAPI): TokenMarketplaceRulesWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenMarketplaceRules.js

@@ -0,0 +1,27 @@
+import { TokenTradeModeWASM } from './TokenTradeMode.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { dppProvider } from '../../provider.js';
+export class TokenMarketplaceRulesWASM {
+    /** @private **/
+    _rawTokenMarketplaceRules;
+    constructor(tradeMode, tradeModeChangeRules) {
+        this._rawTokenMarketplaceRules = new dppProvider.dpp.TokenMarketplaceRulesNAPI(tradeMode._rawTokenTradeMode, tradeModeChangeRules._rawChangeControlRules);
+    }
+    get tradeMode() {
+        return TokenTradeModeWASM.createFromRawInstance(this._rawTokenMarketplaceRules.tradeMode);
+    }
+    set tradeMode(value) {
+        this._rawTokenMarketplaceRules.tradeMode = value._rawTokenTradeMode;
+    }
+    get tradeModeChangeRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenMarketplaceRules.tradeModeChangeRules);
+    }
+    set tradeModeChangeRules(value) {
+        this._rawTokenMarketplaceRules.tradeModeChangeRules = value._rawChangeControlRules;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenMarketplaceRules = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPerpetualDistribution.d.ts

@@ -0,0 +1,13 @@
+import { TokenPerpetualDistributionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { RewardDistributionTypeWASM } from './RewardDistributionType.js';
+import { TokenDistributionRecipientWASM } from './TokenDistributionRecipient.js';
+export declare class TokenPerpetualDistributionWASM {
+    /** @private **/
+    _rawTokenPerpetualDistribution: TokenPerpetualDistributionNAPI;
+    constructor(rewardDistributionType: RewardDistributionTypeWASM, recipient: TokenDistributionRecipientWASM);
+    get distributionType(): RewardDistributionTypeWASM;
+    set distributionType(value: RewardDistributionTypeWASM);
+    get distributionRecipient(): TokenDistributionRecipientWASM;
+    set distributionRecipient(value: TokenDistributionRecipientWASM);
+    static createFromRawInstance(rawInstance: TokenPerpetualDistributionNAPI): TokenPerpetualDistributionWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPerpetualDistribution.js

@@ -0,0 +1,27 @@
+import { RewardDistributionTypeWASM } from './RewardDistributionType.js';
+import { TokenDistributionRecipientWASM } from './TokenDistributionRecipient.js';
+import { dppProvider } from '../../provider.js';
+export class TokenPerpetualDistributionWASM {
+    /** @private **/
+    _rawTokenPerpetualDistribution;
+    constructor(rewardDistributionType, recipient) {
+        this._rawTokenPerpetualDistribution = new dppProvider.dpp.TokenPerpetualDistributionNAPI(rewardDistributionType._rawRewardDistributionType, recipient._rawTokenDistributionRecipient);
+    }
+    get distributionType() {
+        return RewardDistributionTypeWASM.createFromRawInstance(this._rawTokenPerpetualDistribution.distributionType);
+    }
+    set distributionType(value) {
+        this._rawTokenPerpetualDistribution.distributionType = value._rawRewardDistributionType;
+    }
+    get distributionRecipient() {
+        return TokenDistributionRecipientWASM.createFromRawInstance(this._rawTokenPerpetualDistribution.distributionRecipient);
+    }
+    set distributionRecipient(value) {
+        this._rawTokenPerpetualDistribution.distributionRecipient = value._rawTokenDistributionRecipient;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenPerpetualDistribution = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPreProgrammedDistribution.d.ts

@@ -0,0 +1,21 @@
+import { TokenPreProgrammedDistributionNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TokenPreProgrammedDistributionWASM {
+    /** @private **/
+    _rawTokenPreProgrammedDistribution: TokenPreProgrammedDistributionNAPI;
+    constructor(distributions: {
+        [timestamp: string]: {
+            [identifier: string]: bigint;
+        };
+    });
+    get distributions(): {
+        [timestamp: string]: {
+            [identifier: string]: bigint;
+        };
+    };
+    set distributions(distributions: {
+        [timestamp: string]: {
+            [identifier: string]: bigint;
+        };
+    });
+    static createFromRawInstance(rawInstance: TokenPreProgrammedDistributionNAPI): TokenPreProgrammedDistributionWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPreProgrammedDistribution.js

@@ -0,0 +1,42 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+function objectToDistributionArray(distributions) {
+    const timestamps = Object.keys(distributions);
+    const normalDistribution = [];
+    for (const timestamp of timestamps) {
+        const ids = Object.keys(distributions[timestamp]);
+        const identifiersWithAmount = [];
+        for (const identifier of ids) {
+            identifiersWithAmount.push([prepareIdentifierValue(identifier), distributions[timestamp][identifier].toString()]);
+        }
+        normalDistribution.push([timestamp, identifiersWithAmount]);
+    }
+    return normalDistribution;
+}
+export class TokenPreProgrammedDistributionWASM {
+    /** @private **/
+    _rawTokenPreProgrammedDistribution;
+    constructor(distributions) {
+        this._rawTokenPreProgrammedDistribution = new dppProvider.dpp.TokenPreProgrammedDistributionNAPI(objectToDistributionArray(distributions));
+    }
+    get distributions() {
+        const distributions = this._rawTokenPreProgrammedDistribution.distributions;
+        const out = {};
+        for (const [timestamp, identifiers] of distributions) {
+            const ids = {};
+            for (const [id, amount] of identifiers) {
+                ids[id.base58()] = BigInt(amount);
+            }
+            out[timestamp] = ids;
+        }
+        return out;
+    }
+    set distributions(distributions) {
+        this._rawTokenPreProgrammedDistribution.distributions = objectToDistributionArray(distributions);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenPreProgrammedDistribution = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenTradeMode.d.ts

@@ -0,0 +1,9 @@
+import { TokenTradeModeNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TokenTradeModeWASM {
+    /** @private **/
+    _rawTokenTradeMode: TokenTradeModeNAPI;
+    private constructor();
+    getValue(): string;
+    static NotTradeable(): TokenTradeModeWASM;
+    static createFromRawInstance(rawInstance: TokenTradeModeNAPI): TokenTradeModeWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenTradeMode.js

@@ -0,0 +1,17 @@
+import { dppProvider } from '../../provider.js';
+export class TokenTradeModeWASM {
+    /** @private **/
+    _rawTokenTradeMode;
+    constructor(rawInstance) {
+        this._rawTokenTradeMode = rawInstance;
+    }
+    getValue() {
+        return this._rawTokenTradeMode.getValue();
+    }
+    static NotTradeable() {
+        return TokenTradeModeWASM.createFromRawInstance(dppProvider.dpp.TokenTradeModeNAPI.NotTradeable());
+    }
+    static createFromRawInstance(rawInstance) {
+        return new TokenTradeModeWASM(rawInstance);
+    }
+}