@chainstream-io/sdk 0.0.1

package/src/openapi/models/ObjectSerializer.ts

@@ -0,0 +1,497 @@
+export * from '../models/BlockchainLatestBlockDTO';
+export * from '../models/CalculatePnlInput';
+export * from '../models/Candle';
+export * from '../models/ClaimRedPacketInput';
+export * from '../models/CreateRedPacketInput';
+export * from '../models/CreateRedPacketReply';
+export * from '../models/DexDTO';
+export * from '../models/DexMintInput';
+export * from '../models/DexPage';
+export * from '../models/DexPoolDTO';
+export * from '../models/FilterCondition';
+export * from '../models/GainersAndLosersDTO';
+export * from '../models/GainersAndLosersPage';
+export * from '../models/Link';
+export * from '../models/MintInput';
+export * from '../models/MintReply';
+export * from '../models/MoonshotMintReply';
+export * from '../models/MoonshotSubmitMint200Response';
+export * from '../models/PumpMintInput';
+export * from '../models/PumpMintReply';
+export * from '../models/RankingToken';
+export * from '../models/RankingTokenMarketData';
+export * from '../models/RankingTokenStat';
+export * from '../models/RedPacketClaimDTO';
+export * from '../models/RedPacketClaimsPage';
+export * from '../models/RedPacketDTO';
+export * from '../models/RedPacketReply';
+export * from '../models/RedPacketSendTxInput';
+export * from '../models/RedPacketSendTxResponse';
+export * from '../models/RedPacketsPage';
+export * from '../models/Resolution';
+export * from '../models/SendTxInput';
+export * from '../models/SendTxResponse';
+export * from '../models/SubmitInput';
+export * from '../models/SwapInput';
+export * from '../models/SwapReply';
+export * from '../models/SwapRouteInput';
+export * from '../models/SwapRouteResponse';
+export * from '../models/Token';
+export * from '../models/TokenCreationDTO';
+export * from '../models/TokenCreationPage';
+export * from '../models/TokenHolder';
+export * from '../models/TokenHolderPage';
+export * from '../models/TokenListPage';
+export * from '../models/TokenMarketData';
+export * from '../models/TokenMetadata';
+export * from '../models/TokenPage';
+export * from '../models/TokenPriceDTO';
+export * from '../models/TokenPricePage';
+export * from '../models/TokenStat';
+export * from '../models/TopTradersDTO';
+export * from '../models/TopTradersPage';
+export * from '../models/TradeDetailDTO';
+export * from '../models/TradeEvent';
+export * from '../models/TradePage';
+export * from '../models/TradeType';
+export * from '../models/WalletBalanceDetailDTO';
+export * from '../models/WalletBalancesDTO';
+export * from '../models/WalletPnlDTO';
+
+import { BlockchainLatestBlockDTO } from '../models/BlockchainLatestBlockDTO';
+import { CalculatePnlInput } from '../models/CalculatePnlInput';
+import { Candle        } from '../models/Candle';
+import { ClaimRedPacketInput } from '../models/ClaimRedPacketInput';
+import { CreateRedPacketInput } from '../models/CreateRedPacketInput';
+import { CreateRedPacketReply } from '../models/CreateRedPacketReply';
+import { DexDTO } from '../models/DexDTO';
+import { DexMintInput, DexMintInputDexEnum          } from '../models/DexMintInput';
+import { DexPage } from '../models/DexPage';
+import { DexPoolDTO } from '../models/DexPoolDTO';
+import { FilterCondition, FilterConditionFieldEnum     } from '../models/FilterCondition';
+import { GainersAndLosersDTO } from '../models/GainersAndLosersDTO';
+import { GainersAndLosersPage } from '../models/GainersAndLosersPage';
+import { Link , LinkLabelEnum   } from '../models/Link';
+import { MintInput, MintInputDexEnum      , MintInputMigrationDexEnum        } from '../models/MintInput';
+import { MintReply } from '../models/MintReply';
+import { MoonshotMintReply } from '../models/MoonshotMintReply';
+import { MoonshotSubmitMint200Response } from '../models/MoonshotSubmitMint200Response';
+import { PumpMintInput, PumpMintInputDexEnum         , PumpMintInputMigrationDexEnum      } from '../models/PumpMintInput';
+import { PumpMintReply } from '../models/PumpMintReply';
+import { RankingToken } from '../models/RankingToken';
+import { RankingTokenMarketData } from '../models/RankingTokenMarketData';
+import { RankingTokenStat } from '../models/RankingTokenStat';
+import { RedPacketClaimDTO , RedPacketClaimDTOChainEnum         } from '../models/RedPacketClaimDTO';
+import { RedPacketClaimsPage } from '../models/RedPacketClaimsPage';
+import { RedPacketDTO, RedPacketDTOChainEnum                   } from '../models/RedPacketDTO';
+import { RedPacketReply } from '../models/RedPacketReply';
+import { RedPacketSendTxInput } from '../models/RedPacketSendTxInput';
+import { RedPacketSendTxResponse } from '../models/RedPacketSendTxResponse';
+import { RedPacketsPage } from '../models/RedPacketsPage';
+import { Resolution } from '../models/Resolution';
+import { SendTxInput , SendTxInputSubmitTypeEnum    } from '../models/SendTxInput';
+import { SendTxResponse } from '../models/SendTxResponse';
+import { SubmitInput } from '../models/SubmitInput';
+import { SwapInput, SwapInputDexEnum      , SwapInputSwapModeEnum      } from '../models/SwapInput';
+import { SwapReply } from '../models/SwapReply';
+import { SwapRouteInput, SwapRouteInputDexEnum     , SwapRouteInputSwapModeEnum           } from '../models/SwapRouteInput';
+import { SwapRouteResponse } from '../models/SwapRouteResponse';
+import { Token } from '../models/Token';
+import { TokenCreationDTO      , TokenCreationDTOTypeEnum   } from '../models/TokenCreationDTO';
+import { TokenCreationPage } from '../models/TokenCreationPage';
+import { TokenHolder } from '../models/TokenHolder';
+import { TokenHolderPage } from '../models/TokenHolderPage';
+import { TokenListPage } from '../models/TokenListPage';
+import { TokenMarketData } from '../models/TokenMarketData';
+import { TokenMetadata } from '../models/TokenMetadata';
+import { TokenPage } from '../models/TokenPage';
+import { TokenPriceDTO } from '../models/TokenPriceDTO';
+import { TokenPricePage } from '../models/TokenPricePage';
+import { TokenStat } from '../models/TokenStat';
+import { TopTradersDTO } from '../models/TopTradersDTO';
+import { TopTradersPage } from '../models/TopTradersPage';
+import { TradeDetailDTO } from '../models/TradeDetailDTO';
+import { TradeEvent              } from '../models/TradeEvent';
+import { TradePage } from '../models/TradePage';
+import { TradeType } from '../models/TradeType';
+import { WalletBalanceDetailDTO } from '../models/WalletBalanceDetailDTO';
+import { WalletBalancesDTO } from '../models/WalletBalancesDTO';
+import { WalletPnlDTO } from '../models/WalletPnlDTO';
+
+/* tslint:disable:no-unused-variable */
+let primitives = [
+                    "string",
+                    "boolean",
+                    "double",
+                    "integer",
+                    "long",
+                    "float",
+                    "number",
+                    "any"
+                 ];
+
+let enumsMap: Set<string> = new Set<string>([
+    "DexMintInputDexEnum",
+    "FilterConditionFieldEnum",
+    "LinkLabelEnum",
+    "MintInputDexEnum",
+    "MintInputMigrationDexEnum",
+    "PumpMintInputDexEnum",
+    "PumpMintInputMigrationDexEnum",
+    "RedPacketClaimDTOChainEnum",
+    "RedPacketDTOChainEnum",
+    "Resolution",
+    "SendTxInputSubmitTypeEnum",
+    "SwapInputDexEnum",
+    "SwapInputSwapModeEnum",
+    "SwapRouteInputDexEnum",
+    "SwapRouteInputSwapModeEnum",
+    "TokenCreationDTOTypeEnum",
+    "TradeType",
+]);
+
+let typeMap: {[index: string]: any} = {
+    "BlockchainLatestBlockDTO": BlockchainLatestBlockDTO,
+    "CalculatePnlInput": CalculatePnlInput,
+    "Candle": Candle,
+    "ClaimRedPacketInput": ClaimRedPacketInput,
+    "CreateRedPacketInput": CreateRedPacketInput,
+    "CreateRedPacketReply": CreateRedPacketReply,
+    "DexDTO": DexDTO,
+    "DexMintInput": DexMintInput,
+    "DexPage": DexPage,
+    "DexPoolDTO": DexPoolDTO,
+    "FilterCondition": FilterCondition,
+    "GainersAndLosersDTO": GainersAndLosersDTO,
+    "GainersAndLosersPage": GainersAndLosersPage,
+    "Link": Link,
+    "MintInput": MintInput,
+    "MintReply": MintReply,
+    "MoonshotMintReply": MoonshotMintReply,
+    "MoonshotSubmitMint200Response": MoonshotSubmitMint200Response,
+    "PumpMintInput": PumpMintInput,
+    "PumpMintReply": PumpMintReply,
+    "RankingToken": RankingToken,
+    "RankingTokenMarketData": RankingTokenMarketData,
+    "RankingTokenStat": RankingTokenStat,
+    "RedPacketClaimDTO": RedPacketClaimDTO,
+    "RedPacketClaimsPage": RedPacketClaimsPage,
+    "RedPacketDTO": RedPacketDTO,
+    "RedPacketReply": RedPacketReply,
+    "RedPacketSendTxInput": RedPacketSendTxInput,
+    "RedPacketSendTxResponse": RedPacketSendTxResponse,
+    "RedPacketsPage": RedPacketsPage,
+    "SendTxInput": SendTxInput,
+    "SendTxResponse": SendTxResponse,
+    "SubmitInput": SubmitInput,
+    "SwapInput": SwapInput,
+    "SwapReply": SwapReply,
+    "SwapRouteInput": SwapRouteInput,
+    "SwapRouteResponse": SwapRouteResponse,
+    "Token": Token,
+    "TokenCreationDTO": TokenCreationDTO,
+    "TokenCreationPage": TokenCreationPage,
+    "TokenHolder": TokenHolder,
+    "TokenHolderPage": TokenHolderPage,
+    "TokenListPage": TokenListPage,
+    "TokenMarketData": TokenMarketData,
+    "TokenMetadata": TokenMetadata,
+    "TokenPage": TokenPage,
+    "TokenPriceDTO": TokenPriceDTO,
+    "TokenPricePage": TokenPricePage,
+    "TokenStat": TokenStat,
+    "TopTradersDTO": TopTradersDTO,
+    "TopTradersPage": TopTradersPage,
+    "TradeDetailDTO": TradeDetailDTO,
+    "TradeEvent": TradeEvent,
+    "TradePage": TradePage,
+    "WalletBalanceDetailDTO": WalletBalanceDetailDTO,
+    "WalletBalancesDTO": WalletBalancesDTO,
+    "WalletPnlDTO": WalletPnlDTO,
+}
+
+type MimeTypeDescriptor = {
+    type: string;
+    subtype: string;
+    subtypeTokens: string[];
+};
+
+/**
+ * Every mime-type consists of a type, subtype, and optional parameters.
+ * The subtype can be composite, including information about the content format.
+ * For example: `application/json-patch+json`, `application/merge-patch+json`.
+ *
+ * This helper transforms a string mime-type into an internal representation.
+ * This simplifies the implementation of predicates that in turn define common rules for parsing or stringifying
+ * the payload.
+ */
+const parseMimeType = (mimeType: string): MimeTypeDescriptor => {
+    const [type = '', subtype = ''] = mimeType.split('/');
+    return {
+        type,
+        subtype,
+        subtypeTokens: subtype.split('+'),
+    };
+};
+
+type MimeTypePredicate = (mimeType: string) => boolean;
+
+// This factory creates a predicate function that checks a string mime-type against defined rules.
+const mimeTypePredicateFactory = (predicate: (descriptor: MimeTypeDescriptor) => boolean): MimeTypePredicate => (mimeType) => predicate(parseMimeType(mimeType));
+
+// Use this factory when you need to define a simple predicate based only on type and, if applicable, subtype.
+const mimeTypeSimplePredicateFactory = (type: string, subtype?: string): MimeTypePredicate => mimeTypePredicateFactory((descriptor) => {
+    if (descriptor.type !== type) return false;
+    if (subtype != null && descriptor.subtype !== subtype) return false;
+    return true;
+});
+
+// Creating a set of named predicates that will help us determine how to handle different mime-types
+const isTextLikeMimeType = mimeTypeSimplePredicateFactory('text');
+const isJsonMimeType = mimeTypeSimplePredicateFactory('application', 'json');
+const isJsonLikeMimeType = mimeTypePredicateFactory((descriptor) => descriptor.type === 'application' && descriptor.subtypeTokens.some((item) => item === 'json'));
+const isOctetStreamMimeType = mimeTypeSimplePredicateFactory('application', 'octet-stream');
+const isFormUrlencodedMimeType = mimeTypeSimplePredicateFactory('application', 'x-www-form-urlencoded');
+
+// Defining a list of mime-types in the order of prioritization for handling.
+const supportedMimeTypePredicatesWithPriority: MimeTypePredicate[] = [
+    isJsonMimeType,
+    isJsonLikeMimeType,
+    isTextLikeMimeType,
+    isOctetStreamMimeType,
+    isFormUrlencodedMimeType,
+];
+
+const nullableSuffix = " | null";
+const optionalSuffix = " | undefined";
+const arrayPrefix = "Array<";
+const arraySuffix = ">";
+const mapPrefix = "{ [key: string]: ";
+const mapSuffix = "; }";
+
+export class ObjectSerializer {
+    public static findCorrectType(data: any, expectedType: string) {
+        if (data == undefined) {
+            return expectedType;
+        } else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
+            return expectedType;
+        } else if (expectedType === "Date") {
+            return expectedType;
+        } else {
+            if (enumsMap.has(expectedType)) {
+                return expectedType;
+            }
+
+            if (!typeMap[expectedType]) {
+                return expectedType; // w/e we don't know the type
+            }
+
+            // Check the discriminator
+            let discriminatorProperty = typeMap[expectedType].discriminator;
+            if (discriminatorProperty == null) {
+                return expectedType; // the type does not have a discriminator. use it.
+            } else {
+                if (data[discriminatorProperty]) {
+                    var discriminatorType = data[discriminatorProperty];
+                    let mapping = typeMap[expectedType].mapping;
+                    if (mapping != undefined && mapping[discriminatorType]) {
+                        return mapping[discriminatorType]; // use the type given in the discriminator
+                    } else if(typeMap[discriminatorType]) {
+                        return discriminatorType;
+                    } else {
+                        return expectedType; // discriminator did not map to a type
+                    }
+                } else {
+                    return expectedType; // discriminator was not present (or an empty string)
+                }
+            }
+        }
+    }
+
+    public static serialize(data: any, type: string, format: string): any {
+        if (data == undefined) {
+            return data;
+        } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        } else if (type.endsWith(nullableSuffix)) {
+            let subType: string = type.slice(0, -nullableSuffix.length); // Type | null => Type
+            return ObjectSerializer.serialize(data, subType, format);
+        } else if (type.endsWith(optionalSuffix)) {
+            let subType: string = type.slice(0, -optionalSuffix.length); // Type | undefined => Type
+            return ObjectSerializer.serialize(data, subType, format);
+        } else if (type.startsWith(arrayPrefix)) {
+            let subType: string = type.slice(arrayPrefix.length, -arraySuffix.length); // Array<Type> => Type
+            let transformedData: any[] = [];
+            for (let date of data) {
+                transformedData.push(ObjectSerializer.serialize(date, subType, format));
+            }
+            return transformedData;
+        } else if (type.startsWith(mapPrefix)) {
+            let subType: string = type.slice(mapPrefix.length, -mapSuffix.length); // { [key: string]: Type; } => Type
+            let transformedData: { [key: string]: any } = {};
+            for (let key in data) {
+                transformedData[key] = ObjectSerializer.serialize(
+                    data[key],
+                    subType,
+                    format,
+                );
+            }
+            return transformedData;
+        } else if (type === "Date") {
+            if (format == "date") {
+                let month = data.getMonth()+1
+                month = month < 10 ? "0" + month.toString() : month.toString()
+                let day = data.getDate();
+                day = day < 10 ? "0" + day.toString() : day.toString();
+
+                return data.getFullYear() + "-" + month + "-" + day;
+            } else {
+                return data.toISOString();
+            }
+        } else {
+            if (enumsMap.has(type)) {
+                return data;
+            }
+            if (!typeMap[type]) { // in case we dont know the type
+                return data;
+            }
+
+            // Get the actual type of this object
+            type = this.findCorrectType(data, type);
+
+            // get the map for the correct type.
+            let attributeTypes = typeMap[type].getAttributeTypeMap();
+            let instance: {[index: string]: any} = {};
+            for (let attributeType of attributeTypes) {
+                instance[attributeType.baseName] = ObjectSerializer.serialize(data[attributeType.name], attributeType.type, attributeType.format);
+            }
+            return instance;
+        }
+    }
+
+    public static deserialize(data: any, type: string, format: string): any {
+        // polymorphism may change the actual type.
+        type = ObjectSerializer.findCorrectType(data, type);
+        if (data == undefined) {
+            return data;
+        } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        } else if (type.endsWith(nullableSuffix)) {
+            let subType: string = type.slice(0, -nullableSuffix.length); // Type | null => Type
+            return ObjectSerializer.deserialize(data, subType, format);
+        } else if (type.endsWith(optionalSuffix)) {
+            let subType: string = type.slice(0, -optionalSuffix.length); // Type | undefined => Type
+            return ObjectSerializer.deserialize(data, subType, format);
+        } else if (type.startsWith(arrayPrefix)) {
+            let subType: string = type.slice(arrayPrefix.length, -arraySuffix.length); // Array<Type> => Type
+            let transformedData: any[] = [];
+            for (let date of data) {
+                transformedData.push(ObjectSerializer.deserialize(date, subType, format));
+            }
+            return transformedData;
+        } else if (type.startsWith(mapPrefix)) {
+            let subType: string = type.slice(mapPrefix.length, -mapSuffix.length); // { [key: string]: Type; } => Type
+            let transformedData: { [key: string]: any } = {};
+            for (let key in data) {
+                transformedData[key] = ObjectSerializer.deserialize(
+                    data[key],
+                    subType,
+                    format,
+                );
+            }
+            return transformedData;
+        } else if (type === "Date") {
+            return new Date(data);
+        } else {
+            if (enumsMap.has(type)) {// is Enum
+                return data;
+            }
+
+            if (!typeMap[type]) { // dont know the type
+                return data;
+            }
+            let instance = new typeMap[type]();
+            let attributeTypes = typeMap[type].getAttributeTypeMap();
+            for (let attributeType of attributeTypes) {
+                let value = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type, attributeType.format);
+                if (value !== undefined) {
+                    instance[attributeType.name] = value;
+                }
+            }
+            return instance;
+        }
+    }
+
+
+    /**
+     * Normalize media type
+     *
+     * We currently do not handle any media types attributes, i.e. anything
+     * after a semicolon. All content is assumed to be UTF-8 compatible.
+     */
+    public static normalizeMediaType(mediaType: string | undefined): string | undefined {
+        if (mediaType === undefined) {
+            return undefined;
+        }
+        return (mediaType.split(";")[0] ?? '').trim().toLowerCase();
+    }
+
+    /**
+     * From a list of possible media types, choose the one we can handle best.
+     *
+     * The order of the given media types does not have any impact on the choice
+     * made.
+     */
+    public static getPreferredMediaType(mediaTypes: Array<string>): string {
+        /** According to OAS 3 we should default to json */
+        if (mediaTypes.length === 0) {
+            return "application/json";
+        }
+
+        const normalMediaTypes = mediaTypes.map(this.normalizeMediaType);
+
+        for (const predicate of supportedMimeTypePredicatesWithPriority) {
+            for (const mediaType of normalMediaTypes) {
+                if (mediaType != null && predicate(mediaType)) {
+                    return mediaType;
+                }
+            }
+        }
+
+        throw new Error("None of the given media types are supported: " + mediaTypes.join(", "));
+    }
+
+    /**
+     * Convert data to a string according the given media type
+     */
+    public static stringify(data: any, mediaType: string): string {
+        if (isTextLikeMimeType(mediaType)) {
+            return String(data);
+        }
+
+        if (isJsonLikeMimeType(mediaType)) {
+            return JSON.stringify(data);
+        }
+
+        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.stringify.");
+    }
+
+    /**
+     * Parse data from a string according to the given media type
+     */
+    public static parse(rawData: string, mediaType: string | undefined) {
+        if (mediaType === undefined) {
+            throw new Error("Cannot parse content. No Content-Type defined.");
+        }
+
+        if (isTextLikeMimeType(mediaType)) {
+            return rawData;
+        }
+
+        if (isJsonLikeMimeType(mediaType)) {
+            return JSON.parse(rawData);
+        }
+
+        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.parse.");
+    }
+}

package/src/openapi/models/PumpMintInput.ts

@@ -0,0 +1,158 @@
+/**
+ * Dex Aggregator API
+ * Dex Aggregator API ⚡️
+ *
+ * OpenAPI spec version: 1.0
+ * Contact: ai@sx.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { HttpFile } from '../http/http';
+
+export class PumpMintInput {
+    /**
+    * DTO.DEX.IDENTIFIER
+    */
+    'dex': PumpMintInputDexEnum;
+    /**
+    * DTO.DEX.WALLET
+    */
+    'userAddress': string;
+    /**
+    * DTO.DEX.BASE.PRIORITY_FEE
+    */
+    'priorityFee'?: string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.TWITTER
+    */
+    'twitter'?: string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.TELEGRAM
+    */
+    'telegram'?: string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.WEBSITE
+    */
+    'website'?: string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.NAME
+    */
+    'name': string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.SYMBOL
+    */
+    'symbol': string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.MIGRATION_DEX
+    */
+    'migrationDex': PumpMintInputMigrationDexEnum;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.IMAGE
+    */
+    'image': string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.MINT_ADDRESS
+    */
+    'mintAddress': string;
+    /**
+    * DTO.DEX.PUMPFUN.MINT.DESCRIPTION
+    */
+    'description': string;
+
+    static readonly discriminator: string | undefined = undefined;
+
+    static readonly mapping: {[index: string]: string} | undefined = undefined;
+
+    static readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string}> = [
+        {
+            "name": "dex",
+            "baseName": "dex",
+            "type": "PumpMintInputDexEnum",
+            "format": ""
+        },
+        {
+            "name": "userAddress",
+            "baseName": "userAddress",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "priorityFee",
+            "baseName": "priorityFee",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "twitter",
+            "baseName": "twitter",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "telegram",
+            "baseName": "telegram",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "website",
+            "baseName": "website",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "name",
+            "baseName": "name",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "symbol",
+            "baseName": "symbol",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "migrationDex",
+            "baseName": "migrationDex",
+            "type": "PumpMintInputMigrationDexEnum",
+            "format": ""
+        },
+        {
+            "name": "image",
+            "baseName": "image",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "mintAddress",
+            "baseName": "mintAddress",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "description",
+            "baseName": "description",
+            "type": "string",
+            "format": ""
+        }    ];
+
+    static getAttributeTypeMap() {
+        return PumpMintInput.attributeTypeMap;
+    }
+
+    public constructor() {
+    }
+}
+
+export enum PumpMintInputDexEnum {
+    Pumpfun = 'pumpfun'
+}
+export enum PumpMintInputMigrationDexEnum {
+    Raydium = 'RAYDIUM',
+    Meteora = 'METEORA'
+}
+