open-index/open-npm huggingface dataset:
npm package: @paysafe-group/paysafe_sdk_nodejs
Description: Nodejs SDK for Paysafe
Author: Paysafe
Latest version: 2.0.0



# NodePaysafeSDK



## Usage

# Running Sample Code

Navigate to test folder at NodePaysafeSDK->test in Project explore.

Run test case in test folder as Node Application.

Response displayed eclipse console. 

# Running Sample Application

Navigate to server.js at NodePaysafeSDK->sample_application in Project explore.

Run server.js as Node Application.

Open Browser and navigate to:

http://localhost:3000/createProfile

Response displayed herein. 


## Developing



### Tools

Created with [Nodeclipse](https://github.com/Nodeclipse/nodeclipse-1)
 ([Eclipse Marketplace](http://marketplace.eclipse.org/content/nodeclipse), [site](http://www.nodeclipse.org))   

Nodeclipse is free open-source project that grows with your contributions.
npm package: @paysentry/control
Description: Declarative policy engine for AI agent payment control
Latest version: 1.0.2

# @paysentry/control

Declarative policy engine for AI agent payment control. Set spending limits, enforce budgets, require human approval — all without touching your agent code.

Part of [PaySentry](https://github.com/mkmkkkkk/paysentry).

## Install

```bash
npm install @paysentry/control @paysentry/core
```

## Quick Start

```typescript
import { PolicyEngine, blockAbove, requireApprovalAbove, allowAll } from '@paysentry/control';
import { createTransaction } from '@paysentry/core';

const engine = new PolicyEngine();

engine.loadPolicy({
  id: 'production',
  name: 'Production Controls',
  enabled: true,
  rules: [
    blockAbove(1000, 'USDC'),           // Hard block above $1000
    requireApprovalAbove(100, 'USDC'),  // Human approval above $100
    allowAll(),                         // Allow everything else
  ],
  budgets: [
    { window: 'daily', maxAmount: 500, currency: 'USDC' },
    { window: 'monthly', maxAmount: 5000, currency: 'USDC' },
  ],
  cooldownMs: 1000,
});

const tx = createTransaction({
  agentId: 'my-agent',
  recipient: 'api.example.com',
  amount: 50,
  currency: 'USDC',
  purpose: 'API call',
  protocol: 'x402',
});

const result = engine.evaluate(tx);
// result.allowed: boolean
// result.action: 'allow' | 'deny' | 'require_approval' | 'flag'
```

## Features

- **Declarative policies** — JSON/YAML config, no code changes needed
- **Per-agent budgets** — Daily, weekly, monthly spending limits
- **Velocity checks** — Rate limiting and cooldown periods
- **Rule priorities** — First-match evaluation with explicit ordering
- **Express/Fastify middleware** — Drop-in HTTP middleware
- **Deterministic** — No LLM in the decision path

## Express Middleware

```typescript
import { createPolicyMiddleware } from '@paysentry/control';

app.use('/pay', createPolicyMiddleware({ engine }));
```

## License

MIT
npm package: @paysentry/core
Description: Core types, configuration, and shared utilities for PaySentry
Latest version: 1.0.2

# @paysentry/core

Core types, configuration, and shared utilities for [PaySentry](https://github.com/mkmkkkkk/paysentry) — the open-source control plane for AI agent payments.

## Install

```bash
npm install @paysentry/core
```

## Usage

```typescript
import { createTransaction, type AgentTransaction } from '@paysentry/core';

const tx = createTransaction({
  agentId: 'research-agent',
  recipient: 'https://api.provider.com/data',
  amount: 0.05,
  currency: 'USDC',
  purpose: 'Market data API call',
  protocol: 'x402',
});
```

## What's included

| Export | Description |
|--------|-------------|
| `AgentTransaction` | Protocol-agnostic transaction type |
| `PaymentProtocol` | `'x402' \| 'acp' \| 'ap2' \| 'stripe'` |
| `TransactionStatus` | Lifecycle states |
| `PolicyResult` | Policy evaluation result |
| `createTransaction()` | Factory with defaults + ID generation |
| `validateTransaction()` | Runtime validation |

## Part of PaySentry

This is one of 5 packages in the PaySentry monorepo:

- **@paysentry/core** — Types & utilities (this package)
- **@paysentry/observe** — Spend tracking, analytics, alerts
- **@paysentry/control** — Policy engine, spending limits, approval workflows
- **@paysentry/protect** — Provenance, disputes, recovery
- **@paysentry/sandbox** — Mock protocols for testing without real money

## License

MIT
npm package: @paysentry/observe
Description: Payment observability for AI agents — track what agents spend, where, and why
Latest version: 1.0.2

# @paysentry/observe

Payment observability for AI agents. Track what agents spend, where, and why — across x402, ACP, AP2, and Visa TAP.

Part of [PaySentry](https://github.com/mkmkkkkk/paysentry).

## Install

```bash
npm install @paysentry/observe @paysentry/core
```

## Quick Start

```typescript
import { SpendTracker, SpendAnalytics, SpendAlerts } from '@paysentry/observe';

const tracker = new SpendTracker();
const analytics = new SpendAnalytics(tracker);
const alerts = new SpendAlerts(tracker);

// Track a transaction
tracker.record(tx);

// Get per-agent analytics
const report = analytics.getAgentAnalytics('my-agent');
console.log(report.spendByProtocol);
// Map { 'x402:USDC' => { totalAmount: 12.50, transactionCount: 250 } }

// Alert when daily spend exceeds 80% of budget
alerts.addRule({
  id: 'daily-budget',
  type: 'budget_threshold',
  severity: 'warning',
  config: {
    threshold: 500,
    currency: 'USDC',
    windowMs: 86400000,
    alertAtPercent: 0.8,
  },
});

alerts.onAlert((alert) => {
  console.log(`[${alert.severity}] ${alert.message}`);
});
```

## Features

- **SpendTracker** — Real-time transaction indexing by agent, service, protocol
- **SpendAnalytics** — Time-series analytics, per-agent breakdowns, anomaly detection (z-score)
- **SpendAlerts** — Budget thresholds, rate spike detection, new recipient alerts

## License

MIT
npm package: @paysentry/protect
Description: Dispute resolution and recovery for AI agent payments
Latest version: 1.0.2

# @paysentry/protect

Dispute resolution, provenance tracking, and recovery for AI agent payments. Know exactly what happened, prove it, and get your money back.

Part of [PaySentry](https://github.com/mkmkkkkk/paysentry).

## Install

```bash
npm install @paysentry/protect @paysentry/core
```

## Quick Start

```typescript
import { TransactionProvenance, DisputeManager, RecoveryEngine } from '@paysentry/protect';

const provenance = new TransactionProvenance();
const disputes = new DisputeManager({ provenance });

// Record provenance chain: intent -> policy -> execution -> settlement
provenance.recordIntent(tx, { originalPrompt: 'Buy market data' });
provenance.recordPolicyCheck(tx.id, 'pass', { policyId: 'production' });
provenance.recordExecution(tx.id, 'pass', { txHash: '0xabc...' });
provenance.recordSettlement(tx.id, 'fail', { error: 'Service returned 500' });

// File dispute with automatic evidence
const dispute = disputes.file({
  transactionId: tx.id,
  agentId: tx.agentId,
  reason: 'Service failed to deliver after payment',
  requestedAmount: tx.amount,
});

// Resolve
disputes.resolve(dispute.id, {
  status: 'resolved_refunded',
  liability: 'service_provider',
  resolvedAmount: tx.amount,
});
```

## Features

- **TransactionProvenance** — Immutable chain: intent -> policy -> approval -> execution -> settlement
- **DisputeManager** — File, track, and resolve disputes with auto-attached evidence
- **RecoveryEngine** — Automated recovery workflows for failed transactions
- **EU AI Act ready** — Full audit trails for autonomous financial decisions

## License

MIT
npm package: @paysentry/sandbox
Description: Mock multi-protocol payment environment for testing AI agent payments
Latest version: 1.0.2

# @paysentry/sandbox

Mock payment protocols for testing AI agent payments without real money. Simulate x402, ACP, and AP2 with configurable latency, failure rates, and edge cases.

Part of [PaySentry](https://github.com/mkmkkkkk/paysentry).

## Install

```bash
npm install @paysentry/sandbox @paysentry/core
```

## Quick Start

```typescript
import { MockX402, MockACP, MockAP2 } from '@paysentry/sandbox';

// Simulate x402 with 10% failure rate
const x402 = new MockX402({
  latencyMs: 10,
  failureRate: 0.1,
});

const result = await x402.processPayment(tx);
console.log(result.success); // true 90% of the time

// Simulate ACP agent-to-agent
const acp = new MockACP({ latencyMs: 50 });
const negotiation = await acp.negotiate(tx);

// Simulate AP2
const ap2 = new MockAP2({ latencyMs: 20 });
const receipt = await ap2.processPayment(tx);
```

## Features

- **MockX402** — Simulates HTTP 402 payment flow with configurable timeouts and retries
- **MockACP** — Agent-to-agent negotiation simulation
- **MockAP2** — Next-gen protocol mock with receipts
- **Scenarios** — Pre-built edge cases (timeout storms, duplicate payments, network failures)
- **Zero cost** — Test your entire payment flow without spending a cent

## Environment Variable

Set `PAYSENTRY_MODE=sandbox` to route all payments through mocks automatically.

## License

MIT
npm package: @paysera/eslint-config-base
Description: Paysera's base JS ESLint config, following our styleguide
Author: Paysera
Latest version: 1.2.0

# @paysera/eslint-config-base

[![npm version](https://badge.fury.io/js/%40paysera%2Feslint-config-base.svg)](http://badge.fury.io/js/%40paysera%2Feslint-config-base)

This package provides Paysera's base JS .eslintrc (without React plugins) as an extensible shared config.

## Usage

We export two ESLint configurations for your usage.

### @paysera/eslint-config-base

Our default export contains all of our ESLint rules, including ECMAScript 6+. It requires `eslint` and `eslint-plugin-import`.

If you use yarn, run `npm info "@paysera/eslint-config-base@latest" peerDependencies` to list the peer dependencies and versions, then run `yarn add --dev <dependency>@<version>` for each listed peer dependency. See below for npm instructions.

1. Install the correct versions of each package, which are listed by the command:

  ```sh
  npm info "@paysera/eslint-config-base@latest" peerDependencies
  ```

  If using **npm 5+**, use this shortcut

  ```sh
  npx install-peerdeps --dev @paysera/eslint-config-base
  ```

  If using **npm < 5**, Linux/OSX users can run

  ```sh
  (
    export PKG=@paysera/eslint-config-base;
    npm info "$PKG@latest" peerDependencies --json | command sed 's/[\{\},]//g ; s/: /@/g' | xargs npm install --save-dev "$PKG@latest"
  )
  ```

  Which produces and runs a command like:

  ```sh
  npm install --save-dev @paysera/eslint-config-base eslint@^#.#.# eslint-plugin-import@^#.#.#
  ```

  If using **npm < 5**, Windows users can either install all the peer dependencies manually, or use the [install-peerdeps](https://github.com/nathanhleung/install-peerdeps) cli tool.

  ```sh
  npm install -g install-peerdeps
  install-peerdeps --dev @paysera/eslint-config-base
  ```

  The cli will produce and run a command like:

  ```sh
  npm install --save-dev @paysera/eslint-config-base eslint@^#.#.# eslint-plugin-import@^#.#.#
  ```

2. Add `"extends": "@paysera/base"` to your .eslintrc.

See [Paysera's overarching ESLint config](https://npmjs.com/eslint-config-paysera), [Paysera's Javascript styleguide](https://github.com/paysera/js-style-guide), and the [ESlint config docs](https://eslint.org/docs/user-guide/configuring#extending-configuration-files) for more information.

## Improving this config

Consider adding test cases if you're making complicated rules changes, like anything involving regexes. Perhaps in a distant future, we could use literate programming to structure our README as test cases for our .eslintrc?

You can run tests with `npm test`.

You can make sure this module lints with itself using `npm run lint`.
npm package: @paysera/money
Description: A library for working with Money
Author: Paysera
Latest version: 1.2.1

# @paysera/money

Instead of storing prices, profit and any other amount of money in float or integer variable, use Money value object instead. It groups amount with currency, as amount without currency does not give much information.

Basically this library is copy of other great php [library](https://github.com/paysera/lib-money)

For math it use [bignumber.js](https://github.com/MikeMcl/bignumber.js/) library.

## Installation
```shell
npm i @paysera/money
```

## Usage
```js
import { Money } from '@paysera/money';

const money = new Money(1, 'EUR');
const timesTwo = money->mul(2);
money.isLt(timesTwo);
```

## API

`Money` class provides self-contained logic for arithmetic and comparison operations with other `Money` instances. All arithmetic operations returns new `Money` instance.

* `Money::add` - adds current Money amount to given; throws exception if currencies are different.
* `Money::sub` - subtracts given Money amount from current Money amount; throws exception if currencies are different.
* `Money::mul` - multiplies current money amount by given multiplier.
* `Money::div` - divides current money amount by given divisor.
* `Money::negate` - negates current money amount.
* `Money::round` - rounds current money amount to given number of decimal places; if no precision is given, rounds to maximum precision for current currency.
* `Money::ceil` - rounds current money amount to ceil; if no precision is given, rounds to maximum precision for current currency.
* `Money::floor` - rounds current money amount to floor; if no precision is given, rounds to maximum precision for current currency.
* `Money::isGt` - tells if current money is greater than given.
* `Money::isGte` - tells if current money is greater or equal than given.
* `Money::isLt` - tells if current money is less than given.
* `Money::isLte` - tells if current money is less or equal than given.
* `Money::isEqual` - tells if current money is equal to given.
* `Money::isNegative` - tells if current money is negative.
* `Money::isPositive` - tells if current money is positive.
* `Money::isZero` - tells if current money has zero amount.
* `Money::isSameCurrency` - tells if current money has same currency as given.
* `Money::abs` - returns money with absolute amount.
* `Money::getAsString` - returns string with concatenated amount and currency separated by space.
* `Money::getFraction` - returns number of decimal places supported by given currency.
npm package: @paystack-js/rest
Description: A simple Paystack SDK for Node.js
Author: Obi Fortune
Latest version: 0.0.3

# Mantine Hooks

[![npm](https://img.shields.io/npm/dm/@paystack-js/rest)](https://www.npmjs.com/package/@paystack-js/rest)

A simple Paystack SDK for Node.js

## Installation

```bash
# With yarn
yarn add @paystack-js/rest

# With npm
npm install @paystack-js/rest
```

### Usage

```ts
import Paystack from '@paystack/rest';

// initialize with either the token or an object containing the config
const p1 = new Paystack('sk_test_1234567890');
const p2 = new Paystack({
  token: 'sk_test_1234567890',
});

// await the result
const res = await p1.miscellaneous.listBanks();

p1.applePay.listDomains({
  query: { use_cursor: true },
});
p1.applePay.registerDomain({
  body: { domainName: 'example.com' },
});
p1.subAccounts.fetchSubaccount({
  params: { id_or_code: '1234567890' },
});
p1.subAccounts.updateSubaccount({
  params: { id_or_code: '1234567890' },
  body: { active: false },
});
```

## License

MIT
npm package: @paytheory/tweetnacl-sealedbox-js
Description: forked from [whs](https://github.com/whs/tweetnacl-sealed-box) by [Pay Theory](https://github.com/pay-theory/tweetnacl-sealed-box) for maintenance
Latest version: 1.3.2

# libsodium Sealed Box for TweetNaCl.js

forked from [whs](https://github.com/whs/tweetnacl-sealed-box) by [Pay Theory](https://github.com/pay-theory/tweetnacl-sealed-box) for maintenance

This library implements [sealed box](https://doc.libsodium.org/public-key_cryptography/sealed_boxes) for TweetNaCl.

From libsodium's documentation:

>Sealed boxes are designed to anonymously send messages to a recipient given its public key.
>
>Only the recipient can decrypt these messages, using its private key. While the recipient can verify the integrity of the message, it cannot verify the identity of the sender.
>
>A message is encrypted using an ephemeral key pair, whose secret part is destroyed right after the encryption process.
>
>Without knowing the secret key used for a given message, the sender cannot decrypt its own message later. And without additional data, a message cannot be correlated with the identity of its sender.

## Usage

This module can be installed from npm:

```sh
npm install @paytheory/tweetnacl-sealedbox-js
```

For use in web browsers, use [sealedbox.web.js](sealedbox.web.js).

Then you can use it as follow:

```js
var tweetnacl = require('tweetnacl');
tweetnacl.sealedbox = require('tweetnacl-sealedbox-js');

// generate box key pair
var keyPair = tweetnacl.box.keyPair();

// encrypt the message
var sealed = tweetnacl.sealedbox.seal(buffer, keyPair.publicKey);
// sealed will have the size of buffer.length + tweetnacl.sealedbox.overheadLength

// decrypt the message
var result = tweetnacl.sealedbox.open(sealed, keyPair.publicKey, keyPair.secretKey);
```

The message buffer should be a `Uint8Array` or Node.js's `Buffer`. String encoding functions can be found in [tweetnacl-util-js](https://github.com/dchest/tweetnacl-util-js).

Note that `sealedbox.open` may return `null` if the sealed box is tampered.

This library should be interoperable with libsodium's implementation of sealed box (i.e. libsodium sealed box can be opened in this library and vice-versa).

## Security

This library does not zero out memory except for the ephemeral secret key. However, the JavaScript run time in use may not guaranteed that the memory is securely wiped.

_Software has not been audited for security use at your own risk._

## License

This library is licensed under the [MIT license](LICENSE.txt).
npm package: @paytomorrow/pt-transition-plugin
Description: PayTomorrow Financing Transition Plugin
Latest version: 1.0.0

# PayTomorrow Transition Plugin

Try MPE demo here http://transition-demo.paytomorrow.com 

## NPM Setup

### Installation

Via npm:

`npm install @paytomorrow/pt-transition`

### Usage

Import the module:

```javascript

import { 
  addTransitionIframe,
  openTransitionIframe
} from "@paytomorrow/pt-transition";

addTransitionIframe("your_paytomorrow_public_id");

function onPrimaryFinanceRejection() {
  openTransitionIframe();
}

```

## HTML tag setup

### Installation
Copy and paste this on your website:

```html
<!-- Paste in body tag  -->
<script type="text/javascript" src="https://cdn.paytomorrow.com/plugins/transition-plugin/pt-transition.min.js"></script>
```

### Usage

```html
<script>
ptTransition.addTransitionIframe("your_paytomorrow_public_id");

function onPrimeFinanceRejection() {
  ptTransition.openTransitionIframe();
}

document.addEventListener("pt-confirmation", function () {
  createPayTomorrowApplication();
});
document.addEventListener("pt-close", function () {
  redirectToCartPage();
});

</script>
```

## PayTomorrow Transition API

### Public Methods

#### `addTransitionIframe(publicId: string): void;`
 
Appends PayTomorrow's Transition iframe to the bottom of your page and is hidden by default. 

#### `openTransitionIframe(): void;`

Displays PayTomorrow's Transition iframe.

### Events

#### `"pt-confirmation"`
 
Event triggered when consumer clicks the confirm button in the iframe. 

#### `"pt-close"`

Event triggered when consumer clicks the close button in the iframe.
npm package: @paytra/sdk
Description: Paytra API SDK for frontend applications
Author: Paytra Team
Latest version: 1.0.0

# @paytra/sdk

TypeScript SDK used by PAYTRA frontends (`Taka-Money-web-` and other clients) to talk to `paytraApi`.

## What It Provides

- Public auth flow (`/api/v1/auth/*`): login, OTP verify, OTP resend, refresh
- Tenant-scoped API modules:
  - organization
  - clients
  - payments
  - billing
  - ledger
- Centralized token storage and refresh handling
- Tenant-domain request routing after OTP verification

## Project Structure

```text
paytra-sdk/
  src/
    client.ts         # Core HTTP client + interceptors + tenant request helper
    auth.ts           # Public auth flow
    organization.ts   # Organization APIs
    clients.ts        # Client APIs
    payments.ts       # Payment APIs
    billing.ts        # Billing APIs
    ledger.ts         # Ledger APIs
    index.ts          # Public exports
```

## Install & Build

```bash
cd paytra-sdk
npm install
npm run build
```

Build output is generated in `dist/`.

## Use as Local Dependency

In frontend `package.json`:

```json
{
  "dependencies": {
    "@paytra/sdk": "file:../paytra-sdk"
  }
}
```

Then in frontend project:

```bash
npm install
```

## Environment

Create a local env file from [.env.example](.env.example):

```bash
cp .env.example .env
```

`PaytraClient` resolves API base URL in this order:

1. `VITE_PAYTRA_API_URL`
2. `PAYTRA_API_URL`
3. `NEXT_PUBLIC_PAYTRA_API_URL`
4. fallback: `http://localhost:8000`

Base API path remains fixed to `/api/v1`.

## Auth Flow (Current)

1. `auth.login({ workspace, email, password })`
2. if `requires_otp=true`, call `auth.verifyOTP({ email, otp })`
3. SDK stores:
   - `paytra_access_token`
   - `paytra_refresh_token`
   - `paytra_tenant_domain`
4. Tenant module calls use `getTenantRequest(...)`

Notes:

- Backend resolves workspace from `user.merchant`; frontend still passes `workspace` for compatibility.
- Tenant calls require both token and tenant domain from OTP verification response.

## Quick Usage

```ts
import { auth, clients, payments } from "@paytra/sdk";

auth.init();

const login = await auth.login({
  workspace: "",
  email: "owner@example.com",
  password: "OwnerPass123!"
});

if (login.requires_otp) {
  await auth.verifyOTP({ email: "owner@example.com", otp: "123456" });
}

const list = await clients.listClients({ page: 1, page_size: 20 });
const incoming = await payments.listPayments({ page: 1, page_size: 50 });
```

## Common Dev Workflow

When SDK source changes:

```bash
cd paytra-sdk
npm run build
```

Then in frontend:

```bash
cd ../Taka-Money-web-
npm install
npm run dev
```

## Troubleshooting

- `No tenant domain set`:
  - OTP verification was not completed or tenant domain was not stored
- `401` on tenant calls:
  - access token expired and refresh failed
  - sign in again
- Frontend still using old SDK code:
  - rebuild SDK and reinstall in frontend (`npm install`)

---
ignore
useless line
yet another useless line
---
npm package: @paytrail/react-paytrail-e2
Description: React library and component for creating payments with Paytrail E2 interface.
Author: paytrail
Latest version: 2.1.0
Deprecated: Package is no longer supported.

<h1 align="center">react-paytrail-e2 💸</h1>

[![npm version](https://badge.fury.io/js/react-paytrail-e2.svg)](https://badge.fury.io/js/react-paytrail-e2)
![NPM](https://img.shields.io/npm/l/react-paytrail-e2?style=flat-square)

> React library and component for creating payments with [Paytrail E2 Interface][e2].

## Introduction

![Screenshot](screenshot.png)

This library outputs a new `<form>` HTML element including all the required and optional fields as `<input>` elements for the E2 interface. Authcode required by Paytrail is calculated dynamically on render.

Payment may be dispatched to the service by submitting the form. Invalid parameters will instantly be caught by the payment service.

⚠️ This is still a **work-in-progress**. We appreciate your help in testing the logic and fixing any defects found. See how to [contribute](#contributing).

## Install

```sh
# Yarn
yarn add react-paytrail-e2

# NPM
npm install --save react-paytrail-e2
```

## Usage

The payment form component should be added to your existing order page.

```jsx
import { Form } from '@paytrail/react-paytrail-e2'

/* order page JSX */

<Form {...props} />
```

## Demo

This project includes [a demo React application](example/src/App.js) which you can use to study the on how to pass different properties to this component.

## Contributing

The library source code can be found under the `src/` directory, and the example app under the `example/` directory.

First, install dependencies with `yarn`. Then invoke a _Jest_ watcher with `yarn test:unit` to validate your changes.

**NOTE:** As of yet, there's no automated end-to-end test suite for creating a real payment. Make sure the demo application can create a new payment by click of a button and there are no interface errors.

After you're satisfied with the changes and all tests pass, open a pull request to this project.

## Releases

Follow the steps below to release a new version:

1. Checkout to the master branch and make sure tests pass
2. Modify the `version` field in [package.json](package.json) to contain the new version bumped according to semantic versioning rules
3. Commit this change with message `chore: bump version to <version>` (fill in the new version)
4. Push the commit to master branch
5. Go to the releases page on GitHub and draft a new release
6. Fill in the release details and publish

**NOTE:** GitHub Actions pipeline automatically pushes new releases to GitHub package registry when a new release is published. Currently, there's no automatic publishing to NPM registry so it has to be handled manually. Consider using a tool like [`np`][np] to handle releases.

[e2]: https://docs.paytrail.com/payments/e2-interface/
[np]: https://github.com/sindresorhus/np
npm package: @paytrippa/uikit
Description: ## Project setup ``` yarn install ```
Author: Hieu Nguyen
Latest version: 0.1.8

# uikit

## Project setup
```
yarn install
```

### Compiles and hot-reloads for development
```
yarn serve
```

### Compiles and minifies for production
```
yarn build
```

### Run your unit tests
```
yarn test:unit
```

### Lints and fixes files
```
yarn lint
```

### Customize configuration
See [Configuration Reference](https://cli.vuejs.org/config/).