@chainstream-io/sdk 0.0.12 → 0.1.4

package/dist/esm/api/stream.model.d.ts

@@ -0,0 +1,275 @@
+import { Resolution } from "../openapi/src/index";
+export declare enum TokenActivityType {
+    Sell = "sell",
+    Buy = "buy",
+    AddLiquidity = "add_liquidity",
+    RemoveLiquidity = "remove_liquidity"
+}
+export declare enum ChannelType {
+    New = "new",
+    HOT = "trending",
+    US_STOCKS = "us_stocks",
+    COMPLETED = "completed",
+    GRADUATED = "graduated"
+}
+export declare enum MetricType {
+    LIQUIDITY_IN_USD = "liquidity_in_usd",
+    MIGRATED_RATIO = "migrated_ratio"
+}
+export interface TokenActivity {
+    address: string;
+    priceUsd: string;
+    amount: string;
+    type: TokenActivityType;
+    txHash: string;
+    timestamp: number;
+}
+export interface TokenStat {
+    address: string;
+    timestamp: number;
+    buys1m?: number;
+    sells1m?: number;
+    buyers1m?: number;
+    sellers1m?: number;
+    buyVolumeInUsd1m?: string;
+    sellVolumeInUsd1m?: string;
+    price1m?: string;
+    openInUsd1m?: string;
+    closeInUsd1m?: string;
+    buys5m?: number;
+    sells5m?: number;
+    buyers5m?: number;
+    sellers5m?: number;
+    buyVolumeInUsd5m?: string;
+    sellVolumeInUsd5m?: string;
+    price5m?: string;
+    openInUsd5m?: string;
+    closeInUsd5m?: string;
+    buys15m?: number;
+    sells15m?: number;
+    buyers15m?: number;
+    sellers15m?: number;
+    buyVolumeInUsd15m?: string;
+    sellVolumeInUsd15m?: string;
+    price15m?: string;
+    openInUsd15m?: string;
+    closeInUsd15m?: string;
+    buys30m?: number;
+    sells30m?: number;
+    buyers30m?: number;
+    sellers30m?: number;
+    buyVolumeInUsd30m?: string;
+    sellVolumeInUsd30m?: string;
+    price30m?: string;
+    openInUsd30m?: string;
+    closeInUsd30m?: string;
+    buys1h?: number;
+    sells1h?: number;
+    buyers1h?: number;
+    sellers1h?: number;
+    buyVolumeInUsd1h?: string;
+    sellVolumeInUsd1h?: string;
+    price1h?: string;
+    openInUsd1h?: string;
+    closeInUsd1h?: string;
+    buys4h?: number;
+    sells4h?: number;
+    buyers4h?: number;
+    sellers4h?: number;
+    buyVolumeInUsd4h?: string;
+    sellVolumeInUsd4h?: string;
+    price4h?: string;
+    openInUsd4h?: string;
+    closeInUsd4h?: string;
+    buys24h?: number;
+    sells24h?: number;
+    buyers24h?: number;
+    sellers24h?: number;
+    buyVolumeInUsd24h?: string;
+    sellVolumeInUsd24h?: string;
+    price24h?: string;
+    openInUsd24h?: string;
+    closeInUsd24h?: string;
+    price?: string;
+}
+export interface TokenHolder {
+    tokenAddress: string;
+    holders?: number;
+    top100Amount?: string;
+    top10Amount?: string;
+    top100Holders?: number;
+    top10Holders?: number;
+    top100Ratio?: string;
+    top10Ratio?: string;
+    creatorsHolders?: number;
+    creatorsAmount?: string;
+    creatorsRatio?: string;
+    timestamp: number;
+}
+export interface WalletBalance {
+    walletAddress: string;
+    tokenAddress: string;
+    tokenPriceInUsd: string;
+    balance: string;
+    timestamp: number;
+}
+export interface WalletPnl {
+    walletAddress: string;
+    buys: number;
+    buyAmount: string;
+    buyAmountInUsd: string;
+    averageBuyPriceInUsd: string;
+    sellAmount: string;
+    sellAmountInUsd: string;
+    sells: number;
+    wins: number;
+    winRatio: string;
+    pnlInUsd: string;
+    averagePnlInUsd: string;
+    pnlRatio: string;
+    profitableDays: number;
+    losingDays: number;
+    tokens: number;
+    resolution: string;
+}
+export interface NewToken {
+    tokenAddress: string;
+    name: string;
+    symbol: string;
+    decimals?: number;
+    launchFrom?: DexProtocol;
+    createdAtMs: number;
+}
+export interface TokenSupply {
+    tokenAddress: string;
+    supply?: string;
+    marketCapInUsd?: string;
+    timestamp: number;
+}
+export interface DexPoolBalance {
+    poolAddress: string;
+    tokenAAddress: string;
+    tokenALiquidityInUsd: string;
+    tokenBAddress: string;
+    tokenBLiquidityInUsd: string;
+}
+export interface TokenLiquidity {
+    tokenAddress: string;
+    metricType: MetricType;
+    value: string;
+    timestamp: number;
+}
+export interface DexProtocol {
+    programAddress?: string;
+    protocolFamily?: string;
+    protocolName?: string;
+}
+export interface TokenBondingCurve {
+    tokenAddress?: string;
+    progressRatio?: string;
+}
+export interface TokenMetadata {
+    tokenAddress: string;
+    name?: string;
+    decimals?: number;
+    symbol?: string;
+    imageUrl?: string;
+    description?: string;
+    socialMedia?: socialMedia;
+    createdAtMs?: number;
+    launchFrom?: DexProtocol;
+    migratedTo?: DexProtocol;
+}
+export interface socialMedia {
+    twitter?: string;
+    telegram?: string;
+    website?: string;
+    tiktok?: string;
+    discord?: string;
+    facebook?: string;
+    github?: string;
+    instagram?: string;
+    linkedin?: string;
+    medium?: string;
+    reddit?: string;
+    youtube?: string;
+    bitbucket?: string;
+}
+export interface TokenCandle {
+    open: string;
+    close: string;
+    high: string;
+    low: string;
+    volume: string;
+    resolution: Resolution;
+    time: number;
+    number: number;
+}
+export interface TradeActivity {
+    tokenAddress: string;
+    timestamp: number;
+    kind: string;
+    buyAmount: string;
+    buyAmountInUsd: string;
+    buyTokenAddress: string;
+    buyTokenName: string;
+    buyTokenSymbol: string;
+    buyWalletAddress: string;
+    sellAmount: string;
+    sellAmountInUsd: string;
+    sellTokenAddress: string;
+    sellTokenName: string;
+    sellTokenSymbol: string;
+    sellWalletAddress: string;
+    txHash: string;
+}
+export interface WalletTokenPnl {
+    walletAddress: string;
+    tokenAddress: string;
+    tokenPriceInUsd: string;
+    timestamp: number;
+    opentime: number;
+    lasttime: number;
+    closetime: number;
+    buyAmount: string;
+    buyAmountInUsd: string;
+    buyCount: number;
+    buyCount30d: number;
+    buyCount7d: number;
+    sellAmount: string;
+    sellAmountInUsd: string;
+    sellCount: number;
+    sellCount30d: number;
+    sellCount7d: number;
+    heldDurationTimestamp: number;
+    averageBuyPriceInUsd: string;
+    averageSellPriceInUsd: string;
+    unrealizedProfitInUsd: string;
+    unrealizedProfitRatio: string;
+    realizedProfitInUsd: string;
+    realizedProfitRatio: string;
+    totalRealizedProfitInUsd: string;
+    totalRealizedProfitRatio: string;
+}
+export declare enum RankingType {
+    NEW = "new",
+    HOT = "trending",
+    STOCKS = "stocks",
+    FINALSTRETCH = "completed",
+    MIGRATED = "graduated"
+}
+export declare enum Dex {
+    PUMP_FUN = "pump_fun",
+    RAYDIUM_LAUNCHPAD = "raydium_launchpad",
+    METEOR_DYNAMIC_BOUNDING_CURVE = "meteora_dynamic_bounding_curve",
+    BONK_FUN = "bonk_fun",
+    BOOP_FUN = "boop_fun",
+    MOONIT_FUN = "moonit_fun"
+}
+export interface RankingTokenList {
+    metadata?: TokenMetadata;
+    holder?: TokenHolder;
+    supply?: TokenSupply;
+    stat?: TokenStat;
+    bondingCurve?: TokenBondingCurve;
+}

package/dist/esm/api/stream.model.js

@@ -0,0 +1,37 @@
+export var TokenActivityType;
+(function (TokenActivityType) {
+    TokenActivityType["Sell"] = "sell";
+    TokenActivityType["Buy"] = "buy";
+    TokenActivityType["AddLiquidity"] = "add_liquidity";
+    TokenActivityType["RemoveLiquidity"] = "remove_liquidity";
+})(TokenActivityType || (TokenActivityType = {}));
+export var ChannelType;
+(function (ChannelType) {
+    ChannelType["New"] = "new";
+    ChannelType["HOT"] = "trending";
+    ChannelType["US_STOCKS"] = "us_stocks";
+    ChannelType["COMPLETED"] = "completed";
+    ChannelType["GRADUATED"] = "graduated";
+})(ChannelType || (ChannelType = {}));
+export var MetricType;
+(function (MetricType) {
+    MetricType["LIQUIDITY_IN_USD"] = "liquidity_in_usd";
+    MetricType["MIGRATED_RATIO"] = "migrated_ratio";
+})(MetricType || (MetricType = {}));
+export var RankingType;
+(function (RankingType) {
+    RankingType["NEW"] = "new";
+    RankingType["HOT"] = "trending";
+    RankingType["STOCKS"] = "stocks";
+    RankingType["FINALSTRETCH"] = "completed";
+    RankingType["MIGRATED"] = "graduated";
+})(RankingType || (RankingType = {}));
+export var Dex;
+(function (Dex) {
+    Dex["PUMP_FUN"] = "pump_fun";
+    Dex["RAYDIUM_LAUNCHPAD"] = "raydium_launchpad";
+    Dex["METEOR_DYNAMIC_BOUNDING_CURVE"] = "meteora_dynamic_bounding_curve";
+    Dex["BONK_FUN"] = "bonk_fun";
+    Dex["BOOP_FUN"] = "boop_fun";
+    Dex["MOONIT_FUN"] = "moonit_fun";
+})(Dex || (Dex = {}));

package/dist/esm/index.d.ts

@@ -0,0 +1,40 @@
+import { StreamApi } from "./api/stream";
+import { DexApi, Configuration, TransactionApi, DefiSolanaMoonshotApi, DefiSolanaPumpfunApi, DexPoolApi, TokenApi, RankingApi, TradeApi, WalletApi, RedPacketApi, IpfsApi, WatchlistApi, BlockchainApi, JobsApi } from "./openapi/src/index";
+export interface TokenProvider {
+    getToken(): Promise<string> | string;
+}
+export interface DexRequestContext {
+    baseUrl: string;
+    streamUrl: string;
+    accessToken: string | TokenProvider;
+}
+export interface DexAggregatorOptions {
+    debug?: boolean;
+    serverUrl?: string;
+    streamUrl?: string;
+}
+export declare const LIB_VERSION = "0.1.1";
+export declare class DexClient {
+    readonly requestCtx: DexRequestContext;
+    readonly _configuration: Configuration;
+    readonly dex: DexApi;
+    readonly dexpool: DexPoolApi;
+    readonly token: TokenApi;
+    readonly wallet: WalletApi;
+    readonly trade: TradeApi;
+    readonly ranking: RankingApi;
+    readonly transaction: TransactionApi;
+    readonly moonshot: DefiSolanaMoonshotApi;
+    readonly pumpfun: DefiSolanaPumpfunApi;
+    readonly stream: StreamApi;
+    readonly redPacket: RedPacketApi;
+    readonly ipfs: IpfsApi;
+    readonly blockchain: BlockchainApi;
+    readonly watchlist: WatchlistApi;
+    readonly jobs: JobsApi;
+    constructor(accessToken: string | TokenProvider, options?: DexAggregatorOptions);
+    waitForJob<T>(jobId: string, timeout?: number): Promise<T>;
+}
+export interface PostOptions {
+    idempotencyKey?: string;
+}

package/dist/esm/index.js

@@ -0,0 +1,108 @@
+import { StreamApi } from "./api/stream";
+import { DexApi, Configuration, TransactionApi, DefiSolanaMoonshotApi, DefiSolanaPumpfunApi, DexPoolApi, TokenApi, RankingApi, TradeApi, WalletApi, RedPacketApi, IpfsApi, WatchlistApi, BlockchainApi, JobsApi } from "./openapi/src/index";
+import { EventSourcePolyfill } from "event-source-polyfill";
+export const LIB_VERSION = "0.1.1";
+class UserAgentMiddleware {
+    async pre(context) {
+        if (!context.init.headers) {
+            context.init.headers = {};
+        }
+        if (context.init.headers instanceof Headers) {
+            context.init.headers.set("User-Agent", `dex/${LIB_VERSION}/javascript`);
+        }
+        else {
+            context.init.headers["User-Agent"] = `dex/${LIB_VERSION}/javascript`;
+        }
+    }
+    async post(context) {
+    }
+}
+export class DexClient {
+    constructor(accessToken, options = {}) {
+        const baseUrl = options.serverUrl ?? "https://api-dex.chainstream.io";
+        const streamUrl = options.streamUrl ?? "wss://realtime-dex.chainstream.io/connection/websocket";
+        const tokenProvider = typeof accessToken === "string"
+            ? {
+                getToken: () => accessToken,
+            }
+            : accessToken;
+        this.requestCtx = { baseUrl, streamUrl, accessToken };
+        const config = new Configuration({
+            basePath: baseUrl,
+            middleware: [new UserAgentMiddleware()],
+            accessToken: async () => {
+                return typeof accessToken === "string"
+                    ? accessToken
+                    : await accessToken.getToken();
+            },
+            headers: {
+                'User-Agent': `dex/${LIB_VERSION}/javascript`
+            }
+        });
+        this._configuration = config;
+        this.dex = new DexApi(config);
+        this.dexpool = new DexPoolApi(config);
+        this.token = new TokenApi(config);
+        this.trade = new TradeApi(config);
+        this.ranking = new RankingApi(config);
+        this.transaction = new TransactionApi(config);
+        this.moonshot = new DefiSolanaMoonshotApi(config);
+        this.pumpfun = new DefiSolanaPumpfunApi(config);
+        this.stream = new StreamApi(this.requestCtx);
+        this.wallet = new WalletApi(config);
+        this.redPacket = new RedPacketApi(config);
+        this.ipfs = new IpfsApi(config);
+        this.blockchain = new BlockchainApi(config);
+        this.watchlist = new WatchlistApi(config);
+        this.jobs = new JobsApi(config);
+        this.stream.connect();
+    }
+    async waitForJob(jobId, timeout = 60000) {
+        const accessToken = typeof this.requestCtx.accessToken === "string"
+            ? this.requestCtx.accessToken
+            : await this.requestCtx.accessToken.getToken();
+        return new Promise((resolve, reject) => {
+            const sse = new EventSourcePolyfill(`${this.requestCtx.baseUrl}/jobs/${jobId}/streaming`, {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            const timeoutId = setTimeout(() => {
+                sse.close();
+                reject(new Error(`Job ${jobId} timed out after ${timeout}ms`));
+            }, timeout);
+            sse.onmessage = (event) => {
+                try {
+                    console.log("event.data: ", event.data);
+                    const data = JSON.parse(event.data);
+                    if (data.status === "error") {
+                        sse.close();
+                        reject(new Error(`Error: ${data.message}`));
+                    }
+                    else if (data.status === "completed") {
+                        clearTimeout(timeoutId);
+                        sse.close();
+                        resolve(data);
+                    }
+                }
+                catch (e) {
+                    clearTimeout(timeoutId);
+                    sse.close();
+                    reject(new Error("Error parsing event data"));
+                }
+            };
+            sse.onopen = () => {
+                console.log("SSE connection opened");
+            };
+            sse.onerror = (error) => {
+                if (error.message?.includes("No activity within")) {
+                    console.log("SSE reconnecting due to inactivity...");
+                    return;
+                }
+                clearTimeout(timeoutId);
+                sse.close();
+                reject(new Error(`Error in SSE connection: ${error}`));
+            };
+        });
+    }
+}

package/dist/esm/openapi/src/apis/BlockchainApi.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Dex Aggregator API
+ * Dex Aggregator API ⚡️
+ *
+ * The version of the OpenAPI document: 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 * as runtime from '../runtime';
+import type { BlockchainDTO, BlockchainLatestBlockDTO } from '../models/index';
+export interface GetLatestBlockRequest {
+    chain: GetLatestBlockChainEnum;
+}
+/**
+ *
+ */
+export declare class BlockchainApi extends runtime.BaseAPI {
+    /**
+     * CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION
+     * CONTROLLER.GET_LATEST_BLOCK.SUMMARY
+     */
+    getLatestBlockRaw(requestParameters: GetLatestBlockRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BlockchainLatestBlockDTO>>;
+    /**
+     * CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION
+     * CONTROLLER.GET_LATEST_BLOCK.SUMMARY
+     */
+    getLatestBlock(requestParameters: GetLatestBlockRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BlockchainLatestBlockDTO>;
+    /**
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY
+     */
+    getSupportedBlockchainsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<BlockchainDTO>>>;
+    /**
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY
+     */
+    getSupportedBlockchains(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<BlockchainDTO>>;
+}
+/**
+ * @export
+ */
+export declare const GetLatestBlockChainEnum: {
+    readonly Sol: "sol";
+    readonly Base: "base";
+    readonly Bsc: "bsc";
+    readonly Polygon: "polygon";
+    readonly Arbitrum: "arbitrum";
+    readonly Optimism: "optimism";
+    readonly Avalanche: "avalanche";
+    readonly Ethereum: "ethereum";
+    readonly Zksync: "zksync";
+    readonly Sui: "sui";
+};
+export type GetLatestBlockChainEnum = typeof GetLatestBlockChainEnum[keyof typeof GetLatestBlockChainEnum];

package/dist/esm/openapi/src/apis/BlockchainApi.js

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Dex Aggregator API
+ * Dex Aggregator API ⚡️
+ *
+ * The version of the OpenAPI document: 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 * as runtime from '../runtime';
+import { BlockchainDTOFromJSON, BlockchainLatestBlockDTOFromJSON, } from '../models/index';
+/**
+ *
+ */
+export class BlockchainApi extends runtime.BaseAPI {
+    /**
+     * CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION
+     * CONTROLLER.GET_LATEST_BLOCK.SUMMARY
+     */
+    async getLatestBlockRaw(requestParameters, initOverrides) {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError('chain', 'Required parameter "chain" was null or undefined when calling getLatestBlock().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/v1/blockchain/{chain}/latest_block`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => BlockchainLatestBlockDTOFromJSON(jsonValue));
+    }
+    /**
+     * CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION
+     * CONTROLLER.GET_LATEST_BLOCK.SUMMARY
+     */
+    async getLatestBlock(requestParameters, initOverrides) {
+        const response = await this.getLatestBlockRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY
+     */
+    async getSupportedBlockchainsRaw(initOverrides) {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/v1/blockchain`;
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(BlockchainDTOFromJSON));
+    }
+    /**
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY
+     */
+    async getSupportedBlockchains(initOverrides) {
+        const response = await this.getSupportedBlockchainsRaw(initOverrides);
+        return await response.value();
+    }
+}
+/**
+ * @export
+ */
+export const GetLatestBlockChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+};

package/dist/esm/openapi/src/apis/DefiSolanaMoonshotApi.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Dex Aggregator API
+ * Dex Aggregator API ⚡️
+ *
+ * The version of the OpenAPI document: 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 * as runtime from '../runtime';
+import type { MoonshotCreateTokenInput, MoonshotCreateTokenReply, MoonshotSubmitCreateToken200Response, MoonshotSubmitCreateTokenInput } from '../models/index';
+export interface MoonshotCreateTokenRequest {
+    moonshotCreateTokenInput: MoonshotCreateTokenInput;
+}
+export interface MoonshotSubmitCreateTokenRequest {
+    moonshotSubmitCreateTokenInput: MoonshotSubmitCreateTokenInput;
+}
+/**
+ *
+ */
+export declare class DefiSolanaMoonshotApi extends runtime.BaseAPI {
+    /**
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
+     */
+    moonshotCreateTokenRaw(requestParameters: MoonshotCreateTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MoonshotCreateTokenReply>>;
+    /**
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
+     */
+    moonshotCreateToken(requestParameters: MoonshotCreateTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MoonshotCreateTokenReply>;
+    /**
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
+     */
+    moonshotSubmitCreateTokenRaw(requestParameters: MoonshotSubmitCreateTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MoonshotSubmitCreateToken200Response>>;
+    /**
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
+     */
+    moonshotSubmitCreateToken(requestParameters: MoonshotSubmitCreateTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MoonshotSubmitCreateToken200Response>;
+}