@alephium/web3 0.0.3

package/dist/api/api-explorer.d.ts

@@ -0,0 +1,350 @@
+export interface AddressInfo {
+    /** @format uint256 */
+    balance: string;
+    /** @format uint256 */
+    lockedBalance: string;
+    txNumber: number;
+}
+export interface BadRequest {
+    detail: string;
+}
+export interface BlockEntryLite {
+    hash: string;
+    /** @format int64 */
+    timestamp: number;
+    chainFrom: number;
+    chainTo: number;
+    height: number;
+    txNumber: number;
+    mainChain: boolean;
+    /** @format bigint */
+    hashRate: string;
+}
+export interface ConfirmedTransaction {
+    hash: string;
+    blockHash: string;
+    /** @format int64 */
+    timestamp: number;
+    inputs?: Input[];
+    outputs?: Output[];
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    type: string;
+}
+export interface ExplorerInfo {
+    releaseVersion: string;
+    commit: string;
+}
+export interface Hashrate {
+    /** @format int64 */
+    timestamp: number;
+    value: string;
+}
+export interface Input {
+    outputRef: OutputRef;
+    unlockScript?: string;
+    txHashRef: string;
+    address: string;
+    /** @format uint256 */
+    amount: string;
+}
+export interface InternalServerError {
+    detail: string;
+}
+export interface ListBlocks {
+    total: number;
+    blocks?: BlockEntryLite[];
+}
+export interface NotFound {
+    detail: string;
+    resource: string;
+}
+export interface Output {
+    hint: number;
+    key: string;
+    /** @format uint256 */
+    amount: string;
+    address: string;
+    /** @format int64 */
+    lockTime?: number;
+    spent?: string;
+}
+export interface OutputRef {
+    hint: number;
+    key: string;
+}
+export interface PerChainValue {
+    chainFrom: number;
+    chainTo: number;
+    /** @format int64 */
+    value: number;
+}
+export interface ServiceUnavailable {
+    detail: string;
+}
+export interface TokenSupply {
+    /** @format int64 */
+    timestamp: number;
+    /** @format uint256 */
+    total: string;
+    /** @format uint256 */
+    circulating: string;
+    /** @format uint256 */
+    maximum: string;
+}
+export interface Transaction {
+    hash: string;
+    blockHash: string;
+    /** @format int64 */
+    timestamp: number;
+    inputs?: Input[];
+    outputs?: Output[];
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+}
+export declare type TransactionLike = ConfirmedTransaction | UnconfirmedTransaction;
+export interface UInput {
+    outputRef: OutputRef;
+    unlockScript?: string;
+}
+export interface UOutput {
+    /** @format uint256 */
+    amount: string;
+    address: string;
+    /** @format int64 */
+    lockTime?: number;
+}
+export interface Unauthorized {
+    detail: string;
+}
+export interface UnconfirmedTransaction {
+    hash: string;
+    chainFrom: number;
+    chainTo: number;
+    inputs?: UInput[];
+    outputs?: UOutput[];
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    type: string;
+}
+import 'cross-fetch/polyfill';
+export declare type QueryParamsType = Record<string | number, any>;
+export declare type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export interface FullRequestParams extends Omit<RequestInit, 'body'> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseFormat;
+    /** request body */
+    body?: unknown;
+    /** base url */
+    baseUrl?: string;
+    /** request cancellation token */
+    cancelToken?: CancelToken;
+}
+export declare type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+declare type CancelToken = Symbol | string | number;
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor(apiConfig?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    private encodeQueryParam;
+    private addQueryParam;
+    private addArrayQueryParam;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    private mergeRequestParams;
+    private createAbortSignal;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<HttpResponse<T, E>>;
+}
+/**
+ * @title Alephium Explorer API
+ * @version 1.0
+ */
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    blocks: {
+        /**
+         * @description List blocks within time interval
+         *
+         * @tags Blocks
+         * @name GetBlocks
+         * @request GET:/blocks
+         */
+        getBlocks: (query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<HttpResponse<ListBlocks, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description Get a block with hash
+         *
+         * @tags Blocks
+         * @name GetBlocksBlockHash
+         * @request GET:/blocks/{block-hash}
+         */
+        getBlocksBlockHash: (blockHash: string, params?: RequestParams) => Promise<HttpResponse<BlockEntryLite, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description Get block's transactions
+         *
+         * @tags Blocks
+         * @name GetBlocksBlockHashTransactions
+         * @request GET:/blocks/{block-hash}/transactions
+         */
+        getBlocksBlockHashTransactions: (blockHash: string, query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<HttpResponse<Transaction[], BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+    };
+    transactions: {
+        /**
+         * @description Get a transaction with hash
+         *
+         * @tags Transactions
+         * @name GetTransactionsTransactionHash
+         * @request GET:/transactions/{transaction-hash}
+         */
+        getTransactionsTransactionHash: (transactionHash: string, params?: RequestParams) => Promise<HttpResponse<TransactionLike, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+    };
+    addresses: {
+        /**
+         * @description Get address information
+         *
+         * @tags Addressess
+         * @name GetAddressesAddress
+         * @request GET:/addresses/{address}
+         */
+        getAddressesAddress: (address: string, params?: RequestParams) => Promise<HttpResponse<AddressInfo, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description List transactions of a given address
+         *
+         * @tags Addressess
+         * @name GetAddressesAddressTransactions
+         * @request GET:/addresses/{address}/transactions
+         */
+        getAddressesAddressTransactions: (address: string, query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<HttpResponse<Transaction[], BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+    };
+    infos: {
+        /**
+         * @description Get explorer informations
+         *
+         * @tags Infos
+         * @name GetInfos
+         * @request GET:/infos
+         */
+        getInfos: (params?: RequestParams) => Promise<HttpResponse<ExplorerInfo, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description List latest height for each chain
+         *
+         * @tags Infos
+         * @name GetInfosHeights
+         * @request GET:/infos/heights
+         */
+        getInfosHeights: (params?: RequestParams) => Promise<HttpResponse<PerChainValue[], BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description Get token supply list
+         *
+         * @tags Infos
+         * @name GetInfosSupply
+         * @request GET:/infos/supply
+         */
+        getInfosSupply: (query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<HttpResponse<TokenSupply[], BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description Get the ALPH total supply
+         *
+         * @tags Infos
+         * @name GetInfosSupplyTotalAlph
+         * @request GET:/infos/supply/total-alph
+         */
+        getInfosSupplyTotalAlph: (params?: RequestParams) => Promise<HttpResponse<string, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description Get the ALPH circulating supply
+         *
+         * @tags Infos
+         * @name GetInfosSupplyCirculatingAlph
+         * @request GET:/infos/supply/circulating-alph
+         */
+        getInfosSupplyCirculatingAlph: (params?: RequestParams) => Promise<HttpResponse<string, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description Get the total number of transactions
+         *
+         * @tags Infos
+         * @name GetInfosTotalTransactions
+         * @request GET:/infos/total-transactions
+         */
+        getInfosTotalTransactions: (params?: RequestParams) => Promise<HttpResponse<number, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+        /**
+         * @description Get the average block time for each chain
+         *
+         * @tags Infos
+         * @name GetInfosAverageBlockTimes
+         * @request GET:/infos/average-block-times
+         */
+        getInfosAverageBlockTimes: (params?: RequestParams) => Promise<HttpResponse<PerChainValue[], BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+    };
+    charts: {
+        /**
+         * @description `interval-type` query param: hourly, daily
+         *
+         * @tags Charts
+         * @name GetChartsHashrates
+         * @summary Get explorer informations.
+         * @request GET:/charts/hashrates
+         */
+        getChartsHashrates: (query: {
+            fromTs: number;
+            toTs: number;
+            'interval-type': string;
+        }, params?: RequestParams) => Promise<HttpResponse<Hashrate[], BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+    };
+    utils: {
+        /**
+         * @description Perform a sanity check
+         *
+         * @tags Utils
+         * @name PutUtilsSanityCheck
+         * @request PUT:/utils/sanity-check
+         */
+        putUtilsSanityCheck: (params?: RequestParams) => Promise<HttpResponse<void, BadRequest | InternalServerError | NotFound | ServiceUnavailable | Unauthorized>>;
+    };
+}
+export {};

package/dist/api/api-explorer.js

@@ -0,0 +1,297 @@
+"use strict";
+/* eslint-disable */
+/* tslint:disable */
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = exports.HttpClient = exports.ContentType = void 0;
+require("cross-fetch/polyfill");
+var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormData"] = "multipart/form-data";
+    ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+})(ContentType = exports.ContentType || (exports.ContentType = {}));
+class HttpClient {
+    constructor(apiConfig = {}) {
+        this.baseUrl = '';
+        this.securityData = null;
+        this.abortControllers = new Map();
+        this.customFetch = (...fetchParams) => fetch(...fetchParams);
+        this.baseApiParams = {
+            credentials: 'same-origin',
+            headers: {},
+            redirect: 'follow',
+            referrerPolicy: 'no-referrer'
+        };
+        this.setSecurityData = (data) => {
+            this.securityData = data;
+        };
+        this.contentFormatters = {
+            [ContentType.Json]: (input) => input !== null && (typeof input === 'object' || typeof input === 'string') ? JSON.stringify(input) : input,
+            [ContentType.FormData]: (input) => Object.keys(input || {}).reduce((formData, key) => {
+                const property = input[key];
+                formData.append(key, property instanceof Blob
+                    ? property
+                    : typeof property === 'object' && property !== null
+                        ? JSON.stringify(property)
+                        : `${property}`);
+                return formData;
+            }, new FormData()),
+            [ContentType.UrlEncoded]: (input) => this.toQueryString(input)
+        };
+        this.createAbortSignal = (cancelToken) => {
+            if (this.abortControllers.has(cancelToken)) {
+                const abortController = this.abortControllers.get(cancelToken);
+                if (abortController) {
+                    return abortController.signal;
+                }
+                return void 0;
+            }
+            const abortController = new AbortController();
+            this.abortControllers.set(cancelToken, abortController);
+            return abortController.signal;
+        };
+        this.abortRequest = (cancelToken) => {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                abortController.abort();
+                this.abortControllers.delete(cancelToken);
+            }
+        };
+        this.request = (_a) => __awaiter(this, void 0, void 0, function* () {
+            var { body, secure, path, type, query, format, baseUrl, cancelToken } = _a, params = __rest(_a, ["body", "secure", "path", "type", "query", "format", "baseUrl", "cancelToken"]);
+            const secureParams = ((typeof secure === 'boolean' ? secure : this.baseApiParams.secure) &&
+                this.securityWorker &&
+                (yield this.securityWorker(this.securityData))) ||
+                {};
+            const requestParams = this.mergeRequestParams(params, secureParams);
+            const queryString = query && this.toQueryString(query);
+            const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+            const responseFormat = format || requestParams.format;
+            return this.customFetch(`${baseUrl || this.baseUrl || ''}${path}${queryString ? `?${queryString}` : ''}`, Object.assign(Object.assign({}, requestParams), { headers: Object.assign(Object.assign({}, (type && type !== ContentType.FormData ? { 'Content-Type': type } : {})), (requestParams.headers || {})), signal: cancelToken ? this.createAbortSignal(cancelToken) : void 0, body: typeof body === 'undefined' || body === null ? null : payloadFormatter(body) })).then((response) => __awaiter(this, void 0, void 0, function* () {
+                const r = response;
+                r.data = null;
+                r.error = null;
+                const data = !responseFormat
+                    ? r
+                    : yield response[responseFormat]()
+                        .then((data) => {
+                        if (r.ok) {
+                            r.data = data;
+                        }
+                        else {
+                            r.error = data;
+                        }
+                        return r;
+                    })
+                        .catch((e) => {
+                        r.error = e;
+                        return r;
+                    });
+                if (cancelToken) {
+                    this.abortControllers.delete(cancelToken);
+                }
+                if (!response.ok)
+                    throw data;
+                return data;
+            }));
+        });
+        Object.assign(this, apiConfig);
+    }
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === 'number' ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join('&');
+    }
+    toQueryString(rawQuery) {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => 'undefined' !== typeof query[key]);
+        return keys
+            .map((key) => (Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)))
+            .join('&');
+    }
+    addQueryParams(rawQuery) {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : '';
+    }
+    mergeRequestParams(params1, params2) {
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, this.baseApiParams), params1), (params2 || {})), { headers: Object.assign(Object.assign(Object.assign({}, (this.baseApiParams.headers || {})), (params1.headers || {})), ((params2 && params2.headers) || {})) });
+    }
+}
+exports.HttpClient = HttpClient;
+/**
+ * @title Alephium Explorer API
+ * @version 1.0
+ */
+class Api extends HttpClient {
+    constructor() {
+        super(...arguments);
+        this.blocks = {
+            /**
+             * @description List blocks within time interval
+             *
+             * @tags Blocks
+             * @name GetBlocks
+             * @request GET:/blocks
+             */
+            getBlocks: (query, params = {}) => this.request(Object.assign({ path: `/blocks`, method: 'GET', query: query, format: 'json' }, params)),
+            /**
+             * @description Get a block with hash
+             *
+             * @tags Blocks
+             * @name GetBlocksBlockHash
+             * @request GET:/blocks/{block-hash}
+             */
+            getBlocksBlockHash: (blockHash, params = {}) => this.request(Object.assign({ path: `/blocks/${blockHash}`, method: 'GET', format: 'json' }, params)),
+            /**
+             * @description Get block's transactions
+             *
+             * @tags Blocks
+             * @name GetBlocksBlockHashTransactions
+             * @request GET:/blocks/{block-hash}/transactions
+             */
+            getBlocksBlockHashTransactions: (blockHash, query, params = {}) => this.request(Object.assign({ path: `/blocks/${blockHash}/transactions`, method: 'GET', query: query, format: 'json' }, params))
+        };
+        this.transactions = {
+            /**
+             * @description Get a transaction with hash
+             *
+             * @tags Transactions
+             * @name GetTransactionsTransactionHash
+             * @request GET:/transactions/{transaction-hash}
+             */
+            getTransactionsTransactionHash: (transactionHash, params = {}) => this.request(Object.assign({ path: `/transactions/${transactionHash}`, method: 'GET', format: 'json' }, params))
+        };
+        this.addresses = {
+            /**
+             * @description Get address information
+             *
+             * @tags Addressess
+             * @name GetAddressesAddress
+             * @request GET:/addresses/{address}
+             */
+            getAddressesAddress: (address, params = {}) => this.request(Object.assign({ path: `/addresses/${address}`, method: 'GET', format: 'json' }, params)),
+            /**
+             * @description List transactions of a given address
+             *
+             * @tags Addressess
+             * @name GetAddressesAddressTransactions
+             * @request GET:/addresses/{address}/transactions
+             */
+            getAddressesAddressTransactions: (address, query, params = {}) => this.request(Object.assign({ path: `/addresses/${address}/transactions`, method: 'GET', query: query, format: 'json' }, params))
+        };
+        this.infos = {
+            /**
+             * @description Get explorer informations
+             *
+             * @tags Infos
+             * @name GetInfos
+             * @request GET:/infos
+             */
+            getInfos: (params = {}) => this.request(Object.assign({ path: `/infos`, method: 'GET', format: 'json' }, params)),
+            /**
+             * @description List latest height for each chain
+             *
+             * @tags Infos
+             * @name GetInfosHeights
+             * @request GET:/infos/heights
+             */
+            getInfosHeights: (params = {}) => this.request(Object.assign({ path: `/infos/heights`, method: 'GET', format: 'json' }, params)),
+            /**
+             * @description Get token supply list
+             *
+             * @tags Infos
+             * @name GetInfosSupply
+             * @request GET:/infos/supply
+             */
+            getInfosSupply: (query, params = {}) => this.request(Object.assign({ path: `/infos/supply`, method: 'GET', query: query, format: 'json' }, params)),
+            /**
+             * @description Get the ALPH total supply
+             *
+             * @tags Infos
+             * @name GetInfosSupplyTotalAlph
+             * @request GET:/infos/supply/total-alph
+             */
+            getInfosSupplyTotalAlph: (params = {}) => this.request(Object.assign({ path: `/infos/supply/total-alph`, method: 'GET' }, params)),
+            /**
+             * @description Get the ALPH circulating supply
+             *
+             * @tags Infos
+             * @name GetInfosSupplyCirculatingAlph
+             * @request GET:/infos/supply/circulating-alph
+             */
+            getInfosSupplyCirculatingAlph: (params = {}) => this.request(Object.assign({ path: `/infos/supply/circulating-alph`, method: 'GET' }, params)),
+            /**
+             * @description Get the total number of transactions
+             *
+             * @tags Infos
+             * @name GetInfosTotalTransactions
+             * @request GET:/infos/total-transactions
+             */
+            getInfosTotalTransactions: (params = {}) => this.request(Object.assign({ path: `/infos/total-transactions`, method: 'GET' }, params)),
+            /**
+             * @description Get the average block time for each chain
+             *
+             * @tags Infos
+             * @name GetInfosAverageBlockTimes
+             * @request GET:/infos/average-block-times
+             */
+            getInfosAverageBlockTimes: (params = {}) => this.request(Object.assign({ path: `/infos/average-block-times`, method: 'GET', format: 'json' }, params))
+        };
+        this.charts = {
+            /**
+             * @description `interval-type` query param: hourly, daily
+             *
+             * @tags Charts
+             * @name GetChartsHashrates
+             * @summary Get explorer informations.
+             * @request GET:/charts/hashrates
+             */
+            getChartsHashrates: (query, params = {}) => this.request(Object.assign({ path: `/charts/hashrates`, method: 'GET', query: query, format: 'json' }, params))
+        };
+        this.utils = {
+            /**
+             * @description Perform a sanity check
+             *
+             * @tags Utils
+             * @name PutUtilsSanityCheck
+             * @request PUT:/utils/sanity-check
+             */
+            putUtilsSanityCheck: (params = {}) => this.request(Object.assign({ path: `/utils/sanity-check`, method: 'PUT' }, params))
+        };
+    }
+}
+exports.Api = Api;

package/dist/cli/create-project.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};