open-index/open-npm huggingface dataset:
npm package: @haven1/sdk-api-client
Description: Haven1 SDK-API Client
Latest version: 39.0.0

# @haven1/sdk-api-client

The `@haven1/sdk-api-client` package provides seamless connectivity between your project and the Haven1 APIs, adhering to the OpenAPI Specification standard. This package simplifies API interactions by offering typed methods, ensuring a consistent and efficient development experience.

## Key Features

- **OpenAPI Specification Compliance**: Built on OpenAPI standards for robust and scalable API interactions.
- **Type-Safe Integration**: Includes TypeScript support with fully typed responses and requests for improved development confidence.
- **Simplified API Calls**: Ready-to-use methods for common operations, reducing boilerplate code.
- **Flexible Configuration**: Easily customize base URLs, API keys, and other settings.

## Installation

Install the package using your preferred package manager:

::: code-group

```sh [npm]
npm install @haven1/sdk-api-client
```

```sh [pnpm]
pnpm add @haven1/sdk-api-client
```

```sh [yarn]
yarn add @haven1/sdk-api-client
```

:::
npm package: @havena/esm-tenancy-app
Description: Tenancy management app package for the ESM platform
Latest version: 1.0.1

# @havena/esm-tenancy-app

Tenancy management Pilet for the Haven ESM platform. Provides organization and team management functionality including context switching, member management, role assignments, and invitations.

## Installation

```bash
npm install @havena/esm-tenancy-app
# or
yarn add @havena/esm-tenancy-app
```

## Overview

This Pilet extends the Haven ESM shell application with multi-tenancy features:

- **Organization Management**: Create, view, and manage organizations
- **Team Management**: Organize users into teams within organizations
- **Member Management**: Add, remove, and manage organization members
- **Role Management**: Define and assign roles with permissions
- **Invitations**: Send and manage organization invitations
- **Context Switching**: Switch between organizations and teams in the dashboard

## Features

### Context Switcher

Provides an accordion component in the dashboard sidebar for switching between organizations and teams. Displays the current active organization and team.

### Organization Detail Page

A comprehensive page (`/active-organization`) for managing the current active organization with tabs for:

- **Overview**: Organization metrics and general information
- **Roles**: Manage organization roles and permissions
- **Members**: View and manage organization members
- **Teams**: Create and manage teams within the organization
- **Invitations**: Send and manage pending invitations

### Profile Tabs

Extends the user profile page with additional tabs:

- **My Organizations**: List of organizations the user belongs to
- **Invitations**: Pending organization invitations

### Components

- `ContextSwitcher` - Organization and team context switcher
- `OrganizationHeader` - Organization header with basic info
- `OrganizationOverviewTab` - Overview tab with metrics
- `OrganizationMembersTab` - Member management interface
- `OrganizationTeamsTab` - Team management interface
- `OrganizationRolesTab` - Role management interface
- `OrganizationInvitation` - Invitation management interface



## Usage

This is a Pilet that integrates with the Haven ESM shell application. It automatically registers:

- Context switcher extension in the dashboard sidebar
- Organization detail page at `/active-organization`
- Profile tabs for organizations and invitations

## Dependencies

- `@havena/esm-core-api` - Core API library
- `@havena/esm-core-components` - Core components library
- `@havena/esm-shell-app` - Shell application (peer dependency)
- `react-hook-form` - Form handling
- `zod` - Schema validation
- `@hookform/resolvers` - Form validation resolvers

## License

[Add your license information here]
npm package: @havenlife/semotus
Description: A subclass of supertype that synchronizes sets of objects.
Latest version: 4.0.0

# Semotus
## Description

Semotus is a subtype of Supertype that synchronizes a set of objects,
tracking changes and updating the other set when method calls
are made across sets.  It is installed as part of Amorphic.

## License

Semotus is licensed under the MIT license
npm package: @havenlife/supertype
Description: A type system for classical inheritence, mix-ins and composition.
Latest version: 3.4.0

# SuperType
## Description

SuperType is a type system for JavaScript that supports:

- Classical inheritence

- Mixins

- Composition including collections

## Installation
Include `lib/index.js` for use in the browser.  Install on node via npm:

    npm install supertype

It is automatically installed as a dependency for [Amorphic](https://github.com/haven-life/amorphic)

## Example
Classes are defined as "templates".

    ObjectTemplate = require('supertype');

    Animal = ObjectTemplate.create("Animal",
    {
        name: {type: String},
        isMammal: {type: Boolean, value: true},
        legs: {type: Number, value: 2}
    });

    Lion = Animal.extend("Lion",
    {
        init: function () {
            Animal.call(this);
            this.name = "Lion";
            this.legs = 4;
        },
        canRoar: function () {return true}
    });

    Bear = Animal.extend("Bear",
    {
        init: function () {
            Animal.call(this);
            this.name = "Bear";
        },
        canHug: function () {return true}
    });

    Ark = ObjectTemplate.create("Ark",
    {
        animals: {type: Array, of: Animal, value: []},
        board: function (animal) {
            animal.ark = this;
            this.animals.push(animal)
        }
    });
    Animal.mixin(
    {
        ark:    {type: Ark}
    });

You create objects using `new`:

    var ark1 = new Ark();
    ark1.board(new Lion());
    ark1.board(new Bear());

    var ark2 = new Ark();
    ark2.board(new Lion());
    ark2.board(new Bear());


Because SuperType knows about the interrelationships between your objects you can serialize and de-serialize even though you have circular references:

    var serialArk1 = ark1.toJSONString();
    var serialArk2 = ark2.toJSONString();
    ark1 = Ark.fromJSON(serialArk1);
    ark2 = Ark.fromJSON(serialArk2);

## License

SuperType is licensed under the MIT license