open-index/open-npm huggingface dataset:
npm package: @go-waitly/waitly-sdk
Description: Waitly SDK - Your waitlist as code
Author: Antonin Marchard
Latest version: 1.0.4

# Waitly SDK

TS SDK for waitly

## Installation

```bash
npm install @go-waitly/waitly-sdk
```

## How to use

```javascript
import { createWaitlistClient } from '@go-waitly/waitly-sdk';

const client = createWaitlistClient({
  waitlistId: 'YOUR_WAITLIST_ID',
  apiKey: 'YOUR_API_KEY',
});

// Créer une entrée
const response = await client.createWaitlistEntry({
  email: 'user@example.com',
  name: 'John Doe',
});

console.log(`#${response}`);
```

## License

MIT
npm package: @go.saffe/go-saffe-react-js
Description: Go saffe capture component for react js
Author: pedrovictorcruz
Latest version: 1.3.0

# go-saffe-react-js

> Go saffe capture component for react js

[![NPM](https://img.shields.io/npm/v/@go.saffe/go-saffe-react-js.svg)](https://www.npmjs.com/package/@go.saffe/go-saffe-react-js) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save @go.saffe/go-saffe-react-js
```

```bash
yarn add @go.saffe/go-saffe-react-js
```

## Usage

```tsx
import { GoSaffeCapture } from '@go.saffe/go-saffe-react-js'

export function Example() {
  return (
    <GoSaffeCapture
      captureKey='' // capture key (sandbox or production)
      user='' // end-user identifier (either email or CPF)
      type='' // 'onboarding' or 'verification'
      endToEndId='' // identifier to keep consistency between front and backend
      onClose={() => console.log('')} // callback function called when end-user closes (cancels) the capture
      onFinish={() => console.log('')} // callback function called when end-user finishes (completes) the capture
      onTimeout={() => console.log('')} // callback function called when the capture ends for timeout
      extraData={{ // optional extra configuration
        settings: {
          primaryColor: '#00ABAB', // primary color for the capture interface
          secondaryColor: '#6A6A6A', // secondary color for the capture interface
          lang: 'en' // language for the capture interface
        },
        sendResultsTo: {
          media: 'email', // media type for sending results
          email: 'valid_email@domain.com' // email address to where results should be sent
        }
      }}
    />
  )
}
```

The `extraData` parameter is **optional** and allows for dynamic changes specific to the transaction, such as language and colors. It also allows to send sandbox transaction results in a dynamic way to a specific email address.

Primary and secondary colors should be informed in hexadecimal code. Possible values for the key "lang" at the moment are "en" so that the capture interface is presented in english, "pt" for the language to be portuguese, and "es" for spanish.

### Example of `extraData` with color settings only:
```tsx
<GoSaffeCapture
  captureKey='<CAPTURE_KEY>'
  user='<USER_IDENTIFIER>'
  type='<TRANSACTION_TYPE>'
  endToEndId='<END_TO_END_ID>'
  onClose={() => console.log('Capture closed')}
  onFinish={() => console.log('Capture finished')}
  onTimeout={() => console.log('Capture timeout')}
  extraData={{
    settings: {
      primaryColor: '#00ABAB',
      secondaryColor: '#6A6A6A'
    }
  }}
/>
```
npm package: @go.saffe/go-saffe-react-native
Description: Package to render saffe capture
Author: Pedro Cruz
Latest version: 1.5.0

# go-saffe-react-native

Package to render saffe capture.

## Installation

```sh
npm install @go.saffe/go-saffe-react-native
```

## Usage

```js
import SaffeCapture from "@go.saffe/go-saffe-react-native";

// ...
<SaffeCapture
  captureKey={} // capture key (sandbox or production)
  user={} // user identifier (either email or CPF)
  type={} // "onboarding" or "verification"
  endToEndId={} // identifier to keep consistency between front and backend
  onLoad={} // callback function called when component is loading
  onError={} // callback function called to catch error from component
  onClose={} // callback function called when end-user closes (cancels) the capture
  onFinish={} // callback function called when end-user finishes (completes) the capture
  onTimeout={} // callback function called when the capture ends for timeout
  extraData={} // optional extra configuration
/>
```

The `extraData` prop is **optional** and allows for dynamic changes specific to the transaction, such as language and colors.

Primary and secondary colors should be informed in hexadecimal code. Possible values for the key "lang" at the moment are "en" so that the capture interface is presented in english, "pt" for the language to be portuguese, and "es" for spanish.

### Example of `extraData` with color settings:

```js
<SaffeCapture
  // ... other props
  extraData={{
    settings: {
      primaryColor: "#00ABAB",
      secondaryColor: "#6A6A6A",
      lang: "en"
    }
  }}
/>
```

## Native Configuration

This component uses a WebView that requires native permissions to access the camera and location.
Make sure to update the native configuration in your app and note that location must be enabled in our panel.

**iOS (Info.plist):**

```xml
<key>NSCameraUsageDescription</key>
<string>We need camera access</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>We need location access</string>
```

**Android (AndroidManifest.xml):**

```xml
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
```

## Expo Configuration

If you're using Expo, add the following settings in your `app.json` or `app.config.js`:

```json
{
  "expo": {
    "ios": {
      "infoPlist": {
        "NSCameraUsageDescription": "camera access description",
        "NSLocationWhenInUseUsageDescription": "location access description"
      }
    },
    "android": {
      "permissions": [
        "CAMERA",
        "ACCESS_FINE_LOCATION"
      ]
    }
  }
}
```

## Contributing

See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

## License

MIT
npm package: @go1/webhook-verifier-js
Description: [![Node.js CI](https://github.com/go1com/webhook-verifier-js/actions/workflows/node.js.yml/badge.svg)](https://github.com/go1com/webhook-verifier-js/actions/workflows/node.js.yml)
Author: Alex Bergin
Latest version: 1.0.5

# @go1/webhook-verifier-js

[![Node.js CI](https://github.com/go1com/webhook-verifier-js/actions/workflows/node.js.yml/badge.svg)](https://github.com/go1com/webhook-verifier-js/actions/workflows/node.js.yml)

You can use this library to verify the signature passed in the header to your webhook target endpoint.

For more information on signatures with Go1 Webhooks 🔗 [please see this guide](https://developers.go1.com/docs/developer-tools/webhooks/security/#Signatures).

## 📦 Install

    $ npm i @go1/webhook-verifier-js

## 🚀 Usage

### 📥 Verifying Incoming Webhooks

If using a NodeJS framework like ExpressJS, with the [req](https://expressjs.com/en/api.html#req) object in scope:

```js
let signature = req.header('go1-signature');

// payload can be a string OR the object already parsed by the express json middlware
let payload = req.body;

// the secret could come from some place else if you wish, but it is the secret you provided to Go1 when you created the webhook
let secret = process.env.SHARED_SECRET;
```

You can then verify the signature like so:

```js
import { verifySignature } from '@go1/webhook-verifier-js';

verifySignature(signature, payload, secret); // throws an exception if anything is invalid.
```

Or if you prefer not to have exceptions thrown you can also get a result back like so:

```js
import { isSignatureVerified } from '@go1/webhook-verifier-js';

const { isValid, error } = isSignatureVerified(signature, payload, secret);
// { isValid: true, error: undefined }

const { isValid, error } = isSignatureVerified(signature, payload, badSecret);
// { isValid: false, error: InvalidWebhookSignature('Invalid signature') }
```

There is also some optional configuration you can set before calling `verifySignature` or `isSignatureVerified`:

```js

import { configure as configureWebhookVerifier } from '@go1/webhook-verifier-js';

configureWebhookVerifier({
    timestampToleranceInSeconds: 60, // number, defaults to 60
    signatureVersion: 'v1' // string, defaults to 'v1'
});
...
```

### 🔐 Signing Webhook Requests (for internal testing only)

To simulate webhook requests or test signature verification, you can use the built-in CLI tool:

```bash
npm run sign '<shared_secret>' '{"some":"payload"}' [timestamp]
```

This will generate a go1-signature header value in the format expected by `verifySignature()` and `isSignatureVerified()`:

```
Signature: t=1713270112,v1=8a8c94d9...
```

> ⚠️ Note: This is intended for internal development and testing only.

## License

MIT License

## Contributing

Please open an [issue in github here](https://github.com/go1com/webhook-verifier-js/issues) and we will evaluate.
npm package: @go1d/go1d
Description: Go1 Design System
Author: Luke Brooker
Latest version: 15.36.3

# Go1d

## Overview

Go1D (Spoken Gold) stands for Go1 Design System and is a library of mostly static components for building interfaces. This repo should contain minimal components with more stateful components being in `GO1D/Mine` module.

## Installation

```sh
npm install @go1d/go1d
```

## Documentation

- Design documentation can be found at [https://go1d.go1.com/](https://go1d.go1.com/)
- Component story documentation can be found at [https://go1d.go1.com/storybook](https://go1d.go1.com/storybook)