open-index/open-npm huggingface dataset:
npm package: @orchestrator/core
Description: > Core package of Orchestrator library.
Author: Orchestrator
Latest version: 2.0.6

# @orchestrator/core

> Core package of Orchestrator library.

![@orchestrator/core](https://img.shields.io/npm/v/@orchestrator/core)

It is providing capabilities to render UIs dynamically from a JSON like configurations
using Angular components that are registered with it.

## Usage

### Create dynamic component

First you should create some component that you want to be able to render.

To do that - just decorate your component with `@DynamicComponent` decorator
and pass an object with required class that describes it's configuration
and use interface `OrchestratorDynamicComponent` that describes inputs:

```ts
import { Component, Input } from '@angular/core';
import {
  DynamicComponent,
  OrchestratorDynamicComponent,
  Option,
} from '@orchestrator/core';

export class YourComponentConfig {
  @Option()
  title?: string;
}

@Component({
  selector: 'your-dynamic-component',
  template: `Title is {{ config?.title }}`,
})
@DynamicComponent({ config: YourComponentConfig })
export class YourDynamicComponent
  implements OrchestratorDynamicComponent<YourComponentConfig>
{
  @Input()
  items?: OrchestratorConfigItem<any>[];
  @Input()
  config?: YourComponentConfig;
  @Input()
  context?: any;
}
```

- `config` input is a config validated at runtime of your component
  that is provided via the JSON like config for each component
- `context` input is any object that is passed down as a context from the top
- `items` input contains further children of a JSON like subtree
  that your component may or may not decide to render

### Register dynamic component

Next, you should tell Orchestrator which components are available for render.

To do that - just call `OrchestratorCoreModule.withComponents([...])`
with your components in your application module:

```ts
import { NgModule } from '@angular/core';
import { OrchestratorCoreModule } from '@orchestrator/core';
import { YourDynamicComponent } from './your-dynamic.component.ts';

@NgModule({
  imports: [OrchestratorCoreModule.withComponents([YourDynamicComponent])],
})
export class AppModule {}
```

### Render dynamic UI

Finally you are ready to render UI dynamically using `<orc-orchestrator>` component
and passing to it JSON like configuration of your UI:

```ts
import { Component } from '@angular/core';
import { OrchestratorConfigItem } from '@orchestrator/core';

@Component({
  template: `<orc-orchestrator [config]="config"></orc-orchestrator>`,
})
export class MyComponent {
  config: OrchestratorConfigItem<any> = {
    component: 'your-dynamic-component',
    config: { title: 'Dynamic title' },
  };
}
```
npm package: @orchestrator/html-tag
Description: > A component that allows to render any HTML elements for Orchestrator library.
Author: Orchestrator
Latest version: 0.2.1

# @orchestrator/html-tag

> A component that allows to render any HTML elements for Orchestrator library.

![@orchestrator/html-tag](https://img.shields.io/npm/v/@orchestrator/html-tag)

## Registration

```ts
import { NgModule } from '@angular/core';
import { OrchestratorCoreModule } from '@orchestrator/core';
import { HtmlTagModule } from '@orchestrator/html-tag';

@NgModule({
  imports: [OrchestratorCoreModule.forRoot(), HtmlTagModule.forRoot()],
})
export class AppModule {}
```

## Components list

| Component                                                             | Description |
| --------------------------------------------------------------------- | ----------- |
| [orc-html-tag](/libs/html-tag/src/lib/html-tag/html-tag-config.ts)    | Html Tag    |
| [orc-html-text](/libs/html-tag/src/lib/html-text/html-text-config.ts) | HTML Text   |
|                                                                       |             |
npm package: @orchestrator/layout
Description: > A set of simple layout components for Orchestrator library.
Author: Orchestrator
Latest version: 2.0.3

# @orchestrator/layout

> A set of simple layout components for Orchestrator library.

![@orchestrator/layout](https://img.shields.io/npm/v/@orchestrator/layout)

## Registration

```ts
import { NgModule } from '@angular/core';
import { OrchestratorCoreModule } from '@orchestrator/core';
import { LayoutModule } from '@orchestrator/layout';

@NgModule({
  imports: [OrchestratorCoreModule.forRoot(), LayoutModule.forRoot()],
})
export class AppModule {}
```

## Components list

| Component                                                                           | Description                                                     |
| ----------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| [orc-layout-flat-host](/libs/layout/src/lib/layout-flat-host/layout-flat-config.ts) | Allows to render components in a simple flat list using flexbox |
|                                                                                     |                                                                 |
npm package: @orchestrator/ngx-until-destroyed
Description: RxJS operator that unsubscribes from observable on Angular component destruction
Latest version: 1.1.1

# 🤓 Angular - Unsubscribe For Pros 💪

[![Build Status](https://travis-ci.org/orchestratora/ngx-until-destroyed.svg?branch=master)](https://travis-ci.org/orchestratora/ngx-until-destroyed)
[![Coverage](https://img.shields.io/codecov/c/github/orchestratora/ngx-until-destroyed.svg?maxAge=2592000)](https://codecov.io/gh/orchestratora/ngx-until-destroyed)
[![Npm](https://img.shields.io/npm/v/@orchestrator/ngx-until-destroyed.svg)](https://www.npmjs.com/package/@orchestrator/ngx-until-destroyed)
[![Npm Downloads](https://img.shields.io/npm/dt/@orchestrator/ngx-until-destroyed.svg)](https://www.npmjs.com/package/@orchestrator/ngx-until-destroyed)
![Licence](https://img.shields.io/github/license/orchestratora/ngx-until-destroyed.svg)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)

> Declarative way to unsubscribe from observables when the component destroyed

## Installation

```bash
$ npm install @orchestrator/ngx-until-destroyed --save
```

## Usage

```ts
import { untilDestroyed } from '@orchestrator/ngx-until-destroyed';

@Component({
  selector: 'app-inbox',
  templateUrl: './inbox.component.html',
})
export class InboxComponent implements OnInit, OnDestroy {
  ngOnInit() {
    interval(1000)
      .pipe(untilDestroyed(this))
      .subscribe(val => console.log(val));
  }

  // This method must be present, even if empty.
  ngOnDestroy() {
    // To protect you, we'll throw an error if it doesn't exist.
  }
}
```

### Use with decorator

```ts
import { WithUntilDestroyed } from '@orchestrator/ngx-until-destroyed';

@Component({...})
class MyComponent implements OnDestroy {
  @WithUntilDestroyed()
  stream$ = interval(1000); // You can safely subscribe to this everywhere

  // This method must be present, even if empty
  ngOnDestroy() {}
}
```

### Use with any class

```ts
import { untilDestroyed } from '@orchestrator/ngx-until-destroyed';

export class Widget {
  constructor() {
    interval(1000)
      .pipe(untilDestroyed(this, 'destroy'))
      .subscribe(console.log);
  }

  // The name needs to be the same as the decorator parameter
  destroy() {}
}
```
npm package: @orchestrator/stepper
Description: > A stepper component for Orchestrator library.
Author: Orchestrator
Latest version: 2.0.4

# @orchestrator/stepper

> A stepper component for Orchestrator library.

![@orchestrator/stepper](https://img.shields.io/npm/v/@orchestrator/stepper)

## Registration

```ts
import { NgModule } from '@angular/core';
import { OrchestratorCoreModule } from '@orchestrator/core';
import { StepperModule } from '@orchestrator/stepper';

@NgModule({
  imports: [OrchestratorCoreModule.forRoot(), StepperModule.forRoot()],
})
export class AppModule {}
```

## Components list

| Component                                                                | Description                     |
| ------------------------------------------------------------------------ | ------------------------------- |
| [orc-stepper-host](/libs/stepper/src/lib/stepper-host/stepper-config.ts) | Allows to render multiple steps |
| [orc-step-host](/libs/stepper/src/lib/step-host/step-config.ts)          | Allows to render a single step  |
|                                                                          |                                 |
npm package: @orchestrator/ui-web
Description: > A set of basic HTML elements as components for Orchestrator library.
Author: Orchestrator
Latest version: 2.0.4

# @orchestrator/ui-web

> A set of basic HTML elements as components for Orchestrator library.

![@orchestrator/ui-web](https://img.shields.io/npm/v/@orchestrator/ui-web)

**DEPRECATED!**

> Please use [`@orchestrator/html-tag`](/libs/html-tag) package instead
> which has more streamlined API and allows to render any HTML tags available in the Web.

## Registration

```ts
import { NgModule } from '@angular/core';
import { OrchestratorCoreModule } from '@orchestrator/core';
import { UiWebModule } from '@orchestrator/ui-web';

@NgModule({
  imports: [OrchestratorCoreModule.forRoot(), UiWebModule.forRoot()],
})
export class AppModule {}
```

## Components list

| Component                                                                                                  | Description              |
| ---------------------------------------------------------------------------------------------------------- | ------------------------ |
| [orc-ui-web-button-host](/libs/ui-web/src/lib/components/ui-web-button-host/ui-web-button-config.ts)       | Button element           |
| [orc-ui-web-heading-host](/libs/ui-web/src/lib/components/ui-web-heading-host/ui-web-heading-config.ts)    | Heading element (h1..h6) |
| [orc-ui-web-image-host](/libs/ui-web/src/lib/components/ui-web-image-host/ui-web-image-config.ts)          | Image element            |
| [orc-ui-web-input-host](/libs/ui-web/src/lib/components/ui-web-input-host/ui-web-input-config.ts)          | Input element            |
| [orc-ui-web-select-host](/libs/ui-web/src/lib/components/ui-web-select-host/ui-web-select-config.ts)       | Select element           |
| [orc-ui-web-text-host](/libs/ui-web/src/lib/components/ui-web-text-host/ui-web-text-config.ts)             | Paragraph element        |
| [orc-ui-web-textarea-host](/libs/ui-web/src/lib/components/ui-web-textarea-host/ui-web-textarea-config.ts) | Paragraph element        |
|                                                                                                            |                          |
npm package: @orchestree/accounting
Description: Accounting module — Invoices, expenses, banking sync, payroll, financial reports
Author: Orchestree
Latest version: 1.2.0

# @orchestree/accounting

Accounting and financial management for Orchestree. Create invoices, track expenses, manage payroll, and generate financial reports.

## Installation

```bash
npm install @orchestree/accounting
```

## Quick Start

```javascript
const { AccountingClient } = require('@orchestree/accounting');

const client = new AccountingClient({
  apiKey: 'your-api-key',
});

// Create invoice
const invoice = await client.createInvoice({
  invoiceNumber: 'INV-001',
  clientId: 'client-123',
  amount: 5000,
  items: [{ description: 'Services', quantity: 1, unitPrice: 5000 }],
});

// Track expense
await client.trackExpense({
  date: new Date().toISOString(),
  category: 'supplies',
  amount: 250,
});

// Get financial summary
const summary = await client.getFinancialSummary('2024-Q1');
```

## API Reference

### AccountingClient

#### createInvoice(invoiceDef)

Create a new invoice.

```javascript
const invoice = await client.createInvoice({
  invoiceNumber: 'INV-002',
  clientId: 'client-456',
  dueDate: '2024-05-15',
  items: [
    { description: 'Consulting', quantity: 10, unitPrice: 150 }
  ],
});
```

---

#### trackExpense(expenseDef)

Track a business expense.

```javascript
await client.trackExpense({
  date: '2024-04-10',
  category: 'travel',
  amount: 500,
  description: 'Client meeting travel',
});
```

---

#### syncBanking(bankConnection)

Sync banking data.

```javascript
await client.syncBanking({
  bank: 'chase',
  accountId: 'acc-123',
});
```

---

#### runPayroll(payrollDef)

Run payroll processing.

```javascript
const payroll = await client.runPayroll({
  period: '2024-04',
  employees: ['emp-1', 'emp-2'],
});
```

---

## License

MIT
npm package: @orchestree/analytics
Description: Analytics module — Dashboard builder, interactive charts, custom KPIs, scheduled reports
Author: Orchestree
Latest version: 1.4.0

# @orchestree/analytics

Analytics and dashboard builder for Orchestree. Create dashboards, track KPIs, generate reports, and visualize metrics.

## Installation

```bash
npm install @orchestree/analytics
```

## Quick Start

```javascript
const { AnalyticsClient } = require('@orchestree/analytics');

const client = new AnalyticsClient({
  apiKey: 'your-api-key',
});

// Create dashboard
const dashboard = await client.createDashboard({
  name: 'Sales Dashboard',
  description: 'Q2 sales metrics',
});

// Add chart
const chart = await client.addChart(dashboard.id, {
  type: 'line',
  title: 'Revenue Trend',
  metric: 'revenue',
});

// Track KPI
const kpi = await client.trackKPI({
  name: 'Monthly Revenue',
  value: 50000,
  target: 75000,
});

// Generate report
const report = await client.generateReport('sales', {
  period: 'Q2',
});
```

## API Reference

### AnalyticsClient

#### createDashboard(dashboardDef)

Create a new dashboard.

```javascript
const dashboard = await client.createDashboard({
  name: 'Executive Dashboard',
  description: 'KPIs and metrics',
});
```

---

#### addChart(dashboardId, chartDef)

Add a chart to dashboard.

```javascript
const chart = await client.addChart(dashboard.id, {
  type: 'bar',
  title: 'Monthly Sales',
  metric: 'sales',
});
```

---

#### trackKPI(kpiDef)

Track a KPI.

```javascript
await client.trackKPI({
  name: 'Customer Acquisition Cost',
  value: 45,
  target: 35,
  unit: 'USD',
});
```

---

#### generateReport(reportType, options)

Generate a report.

```javascript
const report = await client.generateReport('performance', {
  startDate: '2024-04-01',
  endDate: '2024-04-30',
});
```

---

## License

MIT
npm package: @orchestree/chorus
Description: Chorus module — Real-time channels, threaded conversations, rich messages, bot framework
Author: Orchestree
Latest version: 1.4.0

# @orchestree/chorus

Team communication and bot framework for Orchestree. Build collaborative channels, threads, and intelligent bots for team coordination.

## Installation

```bash
npm install @orchestree/chorus
```

## Quick Start

```javascript
const { ChorusClient } = require('@orchestree/chorus');

const client = new ChorusClient({
  apiKey: 'your-api-key',
});

// Create a channel
const channel = await client.createChannel({
  name: 'announcements',
  type: 'public',
  description: 'Company announcements',
});

// Send a message
await client.sendMessage(channel.id, 'Welcome to the team!');

// Create a thread
const thread = await client.createThread(channel.id, {
  subject: 'Q2 Planning',
});

// Reply to thread
await client.replyToThread(thread.id, 'I have some ideas...');
```

## API Reference

### ChorusClient

#### createChannel(channelDef)

Create a new channel.

```javascript
const channel = await client.createChannel({
  name: 'engineering',
  type: 'private',
  description: 'Engineering team discussions',
});
```

---

#### sendMessage(channelId, message, options)

Send a message to a channel.

```javascript
await client.sendMessage(channel.id, 'New deployment ready!', {
  mentions: ['@devops'],
});
```

---

#### createThread(channelId, threadDef)

Create a thread in a channel.

```javascript
const thread = await client.createThread(channel.id, {
  subject: 'Project Kickoff',
});
```

---

#### replyToThread(threadId, message, options)

Reply to a thread.

```javascript
await client.replyToThread(thread.id, 'Count me in!');
```

---

#### registerBot(botDef)

Register a bot for channel events.

```javascript
const bot = await client.registerBot({
  name: 'notifier',
  endpoint: 'https://bot.example.com/webhook',
  events: ['message.created', 'message.updated'],
});
```

---

#### listChannels(filters)

List all channels.

```javascript
const channels = await client.listChannels({ type: 'public' });
```

---

## License

MIT
npm package: @orchestree/codenza
Description: Codenza module — AI code editor, coding agent, presentation builder, website generator
Author: Orchestree
Latest version: 1.4.0

# @orchestree/codenza

AI-powered code generation, review, and documentation for Orchestree. Generate, review, refactor, and document code with intelligent AI assistance.

## Installation

```bash
npm install @orchestree/codenza
```

## Quick Start

```javascript
const { CodenzaClient } = require('@orchestree/codenza');

const client = new CodenzaClient({
  apiKey: 'your-api-key',
});

// Generate code
const generated = await client.generateCode(
  'Create a function to validate email addresses',
  { language: 'javascript' }
);

// Review code
const review = await client.reviewCode(`
  function validateEmail(email) {
    return email.includes('@');
  }
`);

// Generate documentation
const docs = await client.generateDocs(generated.code);
```

## API Reference

### CodenzaClient

#### generateCode(description, options)

Generate code from description.

```javascript
const code = await client.generateCode('API endpoint for user login', {
  language: 'typescript',
  framework: 'express',
});
```

---

#### reviewCode(code, options)

Review code for quality and best practices.

```javascript
const review = await client.reviewCode(myCode, {
  strict: true,
});
```

---

#### generateDocs(code, options)

Generate documentation for code.

```javascript
const docs = await client.generateDocs(code);
```

---

#### createProject(projectDef)

Create a new project.

```javascript
const project = await client.createProject({
  name: 'MyApp',
  language: 'typescript',
});
```

---

#### listProjects(filters)

List all projects.

```javascript
const projects = await client.listProjects({ language: 'typescript' });
```

---

#### refactorCode(code, options)

Refactor existing code.

```javascript
const refactored = await client.refactorCode(legacyCode);
```

---

## License

MIT
npm package: @orchestree/colab
Description: CoLab module — Video conferencing, real-time whiteboard, AI transcription, recordings
Author: Orchestree
Latest version: 1.4.0

# @orchestree/colab

Collaborative tools and virtual meetings for Orchestree. Create meetings, whiteboards, and transcription services for team collaboration.

## Installation

```bash
npm install @orchestree/colab
```

## Quick Start

```javascript
const { ColabClient } = require('@orchestree/colab');

const client = new ColabClient({
  apiKey: 'your-api-key',
});

// Create meeting
const meeting = await client.createMeeting({
  title: 'Team Sync',
  startTime: new Date().toISOString(),
});

// Start whiteboard
const whiteboard = await client.startWhiteboard(meeting.id);

// Start transcription
const transcription = await client.startTranscription(meeting.id, 'en');

// Get transcript after meeting
const transcript = await client.getTranscript(meeting.id);
```

## API Reference

### ColabClient

#### createMeeting(meetingDef)

Create a new meeting.

```javascript
const meeting = await client.createMeeting({
  title: 'Planning Session',
  startTime: '2024-04-15T10:00:00Z',
});
```

---

#### joinMeeting(meetingId, userDef)

Join an existing meeting.

```javascript
await client.joinMeeting(meeting.id, {
  name: 'John Doe',
  email: 'john@example.com',
});
```

---

#### startWhiteboard(meetingId, options)

Start a whiteboard session.

```javascript
const whiteboard = await client.startWhiteboard(meeting.id);
```

---

#### startTranscription(meetingId, language)

Start real-time transcription.

```javascript
const transcription = await client.startTranscription(meeting.id, 'en');
```

---

#### getRecording(meetingId)

Get meeting recording.

```javascript
const recording = await client.getRecording(meeting.id);
```

---

## License

MIT
npm package: @orchestree/command-center
Description: Command Center module — Fleet grid, real-time alerts, IoT sensor data, mission control
Author: Orchestree
Latest version: 0.9.0

# @orchestree/command-center

Fleet management and IoT control for Orchestree. Monitor devices, manage fleets, and run missions with real-time alerts.

## Installation

```bash
npm install @orchestree/command-center
```

## Quick Start

```javascript
const { CommandCenterClient } = require('@orchestree/command-center');

const client = new CommandCenterClient({
  apiKey: 'your-api-key',
});

// Connect a device
const device = await client.connectDevice({
  name: 'Sensor-01',
  type: 'temperature',
  location: { lat: 37.7749, lng: -122.4194 },
});

// Get fleet status
const fleet = await client.getFleetStatus('fleet-123');

// Get sensor data
const data = await client.getSensorData(device.id, {
  start: '2024-04-01',
  end: '2024-04-15',
});

// Run a mission
const mission = await client.runMission({
  name: 'Area Scan',
  devices: [device.id],
});
```

## API Reference

### CommandCenterClient

#### getFleetStatus(fleetId)

Get fleet status information.

```javascript
const status = await client.getFleetStatus('fleet-123');
```

---

#### connectDevice(deviceDef)

Connect a new device.

```javascript
const device = await client.connectDevice({
  name: 'Sensor-02',
  type: 'humidity',
});
```

---

#### getSensorData(deviceId, timeRange)

Retrieve sensor readings.

```javascript
const readings = await client.getSensorData('device-123', {
  start: '2024-04-10',
  end: '2024-04-15',
});
```

---

#### runMission(missionDef)

Run a mission on devices.

```javascript
const mission = await client.runMission({
  name: 'Delivery',
  devices: ['dev-1', 'dev-2'],
});
```

---

## License

MIT
npm package: @orchestree/commerce
Description: Commerce module — Storefront builder, checkout flow, subscriptions, marketplace, inventory
Author: Orchestree
Latest version: 1.2.0

# @orchestree/commerce

E-commerce platform for Orchestree. Build storefronts, manage inventory, process checkouts, and handle subscriptions.

## Installation

```bash
npm install @orchestree/commerce
```

## Quick Start

```javascript
const { CommerceClient } = require('@orchestree/commerce');

const client = new CommerceClient({
  apiKey: 'your-api-key',
});

// Create a product
const product = await client.createProduct({
  name: 'Premium Widget',
  sku: 'WIDGET-001',
  price: 29.99,
  inventory: 100,
});

// Process checkout
const order = await client.processCheckout(
  [{ productId: product.id, quantity: 2, price: 29.99 }],
  { email: 'customer@example.com', name: 'John Doe' }
);

// Create subscription
const subscription = await client.createSubscription({
  customerId: 'cust-123',
  productId: product.id,
  billingCycle: 'monthly',
});
```

## API Reference

### CommerceClient

#### createProduct(productDef)

Create a new product.

```javascript
const product = await client.createProduct({
  name: 'Widget',
  sku: 'WDG-001',
  price: 19.99,
  inventory: 50,
});
```

---

#### processCheckout(cartItems, customerInfo)

Process a checkout.

```javascript
const order = await client.processCheckout(
  [{ productId: 'prod-123', quantity: 1, price: 19.99 }],
  { email: 'user@example.com' }
);
```

---

#### createSubscription(subscriptionDef)

Create a subscription.

```javascript
const sub = await client.createSubscription({
  customerId: 'cust-123',
  productId: 'prod-456',
  billingCycle: 'monthly',
});
```

---

#### getOrders(filters)

List orders.

```javascript
const orders = await client.getOrders({ status: 'delivered' });
```

---

#### updateInventory(productId, quantity)

Update product inventory.

```javascript
await client.updateInventory('prod-123', 75);
```

---

## License

MIT
npm package: @orchestree/databases
Description: Databases module — Table views, formula engine, automation triggers, form builder
Author: Orchestree
Latest version: 1.4.0

# @orchestree/databases

Database and table management for Orchestree. Create tables, manage records, build forms, and automate workflows with formulas.

## Installation

```bash
npm install @orchestree/databases
```

## Quick Start

```javascript
const { DatabasesClient } = require('@orchestree/databases');

const client = new DatabasesClient({
  apiKey: 'your-api-key',
});

// Create a table
const table = await client.createTable({
  name: 'Contacts',
  fields: [
    { name: 'Name', type: 'text', required: true },
    { name: 'Email', type: 'email', required: true },
    { name: 'Phone', type: 'phone' },
  ],
});

// Add a record
const record = await client.addRecord(table.id, {
  Name: 'John Doe',
  Email: 'john@example.com',
  Phone: '+1-555-0100',
});

// Create a form
const form = await client.createForm(table.id, {
  name: 'Contact Form',
  collectEmail: true,
});
```

## API Reference

### DatabasesClient

#### createTable(tableDef)

Create a new table.

```javascript
const table = await client.createTable({
  name: 'Projects',
  fields: [
    { name: 'Title', type: 'text' },
    { name: 'Status', type: 'select', options: ['Active', 'Complete'] },
  ],
});
```

---

#### addRecord(tableId, record)

Add a record to a table.

```javascript
const record = await client.addRecord(table.id, {
  Title: 'Website Redesign',
  Status: 'Active',
});
```

---

#### updateRecord(tableId, recordId, updates)

Update a record.

```javascript
await client.updateRecord(table.id, record.id, {
  Status: 'Complete',
});
```

---

#### queryRecords(tableId, query)

Query records from a table.

```javascript
const records = await client.queryRecords(table.id, {
  filter: { Status: 'Active' },
  sort: { Title: 'asc' },
});
```

---

## License

MIT
npm package: @orchestree/documents
Description: Documents module — E-signature flows, document templates, envelope management, audit trails
Author: Orchestree
Latest version: 1.2.0

# @orchestree/documents

Document management and e-signature services for Orchestree. Create, send, sign, and manage documents with automated workflows.

## Installation

```bash
npm install @orchestree/documents
```

## Quick Start

```javascript
const { DocumentsClient } = require('@orchestree/documents');

const client = new DocumentsClient({
  apiKey: 'your-api-key',
});

// Create an envelope
const envelope = await client.createEnvelope({
  name: 'Contract Review',
  documents: ['doc-123'],
  recipients: [
    { email: 'signer@example.com', name: 'Jane Doe', role: 'signer' },
  ],
});

// Send envelope
await client.sendEnvelope(envelope.id);

// Check signature status
const status = await client.getSignatureStatus('doc-123');
```

## API Reference

### DocumentsClient

#### createEnvelope(envelopeDef)

Create a document envelope.

```javascript
const envelope = await client.createEnvelope({
  name: 'NDA',
  documents: ['doc-456'],
  recipients: [
    { email: 'legal@company.com', name: 'Legal Team', role: 'signer' },
  ],
});
```

---

#### requestSignature(documentId, signers)

Request signatures on a document.

```javascript
await client.requestSignature('doc-456', [
  { email: 'user1@example.com', name: 'User 1', role: 'signer' },
  { email: 'user2@example.com', name: 'User 2', role: 'approver' },
]);
```

---

#### getSignatureStatus(documentId)

Get signature status.

```javascript
const status = await client.getSignatureStatus('doc-456');
```

---

#### createTemplate(templateDef)

Create a document template.

```javascript
const template = await client.createTemplate({
  name: 'Service Agreement',
  content: '<html>...</html>',
});
```

---

## License

MIT
npm package: @orchestree/enterprise
Description: Enterprise module — Team management, SSO/SAML, RBAC permissions, audit logs, compliance
Author: Orchestree
Latest version: 1.2.0

# @orchestree/enterprise

Enterprise team and SSO management for Orchestree. Manage teams, configure single sign-on, set up RBAC, and audit activity.

## Installation

```bash
npm install @orchestree/enterprise
```

## Quick Start

```javascript
const { EnterpriseClient } = require('@orchestree/enterprise');

const client = new EnterpriseClient({
  apiKey: 'your-api-key',
});

// Create a team
const team = await client.createTeam({
  name: 'Engineering',
});

// Invite user
await client.inviteUser('john@company.com', 'member');

// Configure SSO
await client.configureSSO({
  provider: 'okta',
  clientId: 'your-client-id',
  domain: 'company.okta.com',
});

// Set up RBAC
await client.configureRBAC({
  roles: [
    { name: 'admin', permissions: ['read', 'write', 'delete'] },
    { name: 'member', permissions: ['read', 'write'] },
  ],
});

// Get audit log
const logs = await client.getAuditLog({ limit: 100 });
```

## API Reference

### EnterpriseClient

#### createTeam(teamDef)

Create a new team.

```javascript
const team = await client.createTeam({
  name: 'Product',
});
```

---

#### configureSSO(ssoConfig)

Configure single sign-on.

```javascript
await client.configureSSO({
  provider: 'google',
  clientId: 'client-id',
  clientSecret: 'client-secret',
});
```

---

#### configureRBAC(rbacConfig)

Configure role-based access control.

```javascript
await client.configureRBAC({
  roles: [
    { name: 'owner', permissions: ['*'] },
    { name: 'editor', permissions: ['read', 'write'] },
  ],
});
```

---

#### listUsers(filters)

List organization users.

```javascript
const users = await client.listUsers({ status: 'active' });
```

---

#### inviteUser(email, role)

Invite a user to the organization.

```javascript
await client.inviteUser('user@company.com', 'member');
```

---

#### getAuditLog(filters)

Get audit log entries.

```javascript
const logs = await client.getAuditLog({
  action: 'user.created',
  days: 30,
});
```

---

## License

MIT
npm package: @orchestree/forgestudio
Description: ForgeStudio module — Visual editor, plugin system, marketplace, AI asset generation
Author: Orchestree
Latest version: 1.4.0

# @orchestree/forgestudio

AI-powered asset generation and brand management for Orchestree. Create, manage, and deploy brand-consistent design assets at scale.

## Installation

```bash
npm install @orchestree/forgestudio
```

## Quick Start

```javascript
const { ForgeClient } = require('@orchestree/forgestudio');

const client = new ForgeClient({
  apiKey: 'your-api-key',
});

// Generate an asset
const asset = await client.generateAsset('social-banner', {
  description: 'Summer promotion banner',
  dimensions: '1200x630',
  colorScheme: ['#FF6B6B', '#4ECDC4'],
});

// Create a brand kit
const brandKit = await client.createBrandKit({
  name: 'Brand 2024',
  colors: {
    primary: '#FF6B6B',
    secondary: '#4ECDC4',
  },
  fonts: ['Inter', 'Playfair Display'],
});
```

## API Reference

### ForgeClient

#### generateAsset(assetType, spec)

Generate a new asset.

```javascript
const asset = await client.generateAsset('social-post', {
  description: 'Product launch announcement',
  style: 'modern',
  dimensions: '1080x1080',
});
```

---

#### getBrandKit(brandKitId)

Retrieve a brand kit.

```javascript
const kit = await client.getBrandKit('brand-123');
```

---

#### updateBrandKit(brandKitId, updates)

Update brand kit.

```javascript
await client.updateBrandKit('brand-123', {
  colors: { primary: '#FF6B6B' },
});
```

---

#### createTemplate(templateDef)

Create a design template.

```javascript
const template = await client.createTemplate({
  name: 'Email Newsletter',
  category: 'email',
  description: 'Monthly newsletter template',
});
```

---

#### listTemplates(filters)

List available templates.

```javascript
const templates = await client.listTemplates({
  category: 'social',
});
```

---

#### getMarketplace(category)

Get marketplace items.

```javascript
const items = await client.getMarketplace('icons');
```

---

## License

MIT
npm package: @orchestree/inbox
Description: Inbox module — Unified notification feed, AI priority scoring, smart triage, daily digest
Author: Orchestree
Latest version: 1.2.0

# @orchestree/inbox

Notification and message management for Orchestree. Manage feeds, triage notifications, and generate intelligent digests.

## Installation

```bash
npm install @orchestree/inbox
```

## Quick Start

```javascript
const { InboxClient } = require('@orchestree/inbox');

const client = new InboxClient({
  apiKey: 'your-api-key',
});

// Get feed
const feed = await client.getFeed({ limit: 20 });

// Mark as read
await client.markRead(feed[0].id);

// Triage items
await client.triageItems([feed[1].id, feed[2].id], 'alerts');

// Generate digest
const digest = await client.generateDigest({ period: 'daily' });
```

## API Reference

### InboxClient

#### getFeed(filters)

Get inbox feed.

```javascript
const items = await client.getFeed({
  priority: 'high',
  limit: 30,
});
```

---

#### markRead(itemId)

Mark item as read.

```javascript
await client.markRead('item-123');
```

---

#### triageItems(itemIds, category)

Categorize multiple items.

```javascript
await client.triageItems(['item-1', 'item-2'], 'important');
```

---

#### generateDigest(options)

Generate a digest of items.

```javascript
const digest = await client.generateDigest({
  period: 'daily',
  includeCategories: ['alerts', 'updates'],
});
```

---

## License

MIT
npm package: @orchestree/landing
Description: Landing Pages module — Drag-and-drop page builder, A/B testing, SEO toolkit, templates
Author: Orchestree
Latest version: 1.2.0

# @orchestree/landing

Landing page builder for Orchestree. Create and optimize landing pages with A/B testing and SEO analysis.

## Installation

```bash
npm install @orchestree/landing
```

## Quick Start

```javascript
const { LandingClient } = require('@orchestree/landing');

const client = new LandingClient({
  apiKey: 'your-api-key',
});

// Create a landing page
const page = await client.createPage({
  title: 'Product Launch',
  slug: 'product-launch',
  seoTitle: 'New Product - Limited Time Offer',
});

// Publish page
await client.publishPage(page.id);

// Create A/B test
const test = await client.createABTest({
  name: 'CTA Button Test',
  variantA: page.id,
  variantB: page.id + '-variant',
});

// Analyze SEO
const seoAnalysis = await client.analyzeSEO(page.id);
```

## API Reference

### LandingClient

#### createPage(pageDef)

Create a landing page.

```javascript
const page = await client.createPage({
  title: 'Webinar Signup',
  slug: 'webinar-2024',
  seoTitle: 'Free Webinar Registration',
});
```

---

#### publishPage(pageId)

Publish a page.

```javascript
await client.publishPage(page.id);
```

---

#### createABTest(testDef)

Create an A/B test.

```javascript
const test = await client.createABTest({
  name: 'Headline Test',
  variantA: 'page-1',
  variantB: 'page-2',
});
```

---

#### getABResults(testId)

Get A/B test results.

```javascript
const results = await client.getABResults(test.id);
```

---

#### analyzeSEO(pageId)

Analyze page SEO.

```javascript
const analysis = await client.analyzeSEO(page.id);
```

---

## License

MIT
npm package: @orchestree/moonroom
Description: MoonRoom module — Portfolio tracking, trading UI, DeFi integrations, NFT tools, AI Lab
Author: Orchestree
Latest version: 0.9.0

# @orchestree/moonroom

Portfolio tracking and AI-powered trading for Orchestree. Manage investments, track performance, and execute trades with intelligent market analysis.

## Installation

```bash
npm install @orchestree/moonroom
```

## Quick Start

```javascript
const { MoonRoomClient } = require('@orchestree/moonroom');

const client = new MoonRoomClient({
  apiKey: 'your-api-key',
});

// Get portfolio
const portfolio = await client.getPortfolio();

// Execute trade
const trade = await client.executeTrade({
  symbol: 'AAPL',
  action: 'buy',
  quantity: 10,
  orderType: 'market',
});

// Get market data
const market = await client.getMarketData('AAPL');

// Run AI analysis
const analysis = await client.runAIAnalysis('portfolio-optimization');
```

## API Reference

### MoonRoomClient

#### getPortfolio(portfolioId)

Get portfolio information.

```javascript
const portfolio = await client.getPortfolio();
```

---

#### executeTrade(tradeSpec)

Execute a trade.

```javascript
const trade = await client.executeTrade({
  symbol: 'AAPL',
  action: 'buy',
  quantity: 10,
  price: 150.25,
});
```

---

#### listNFTs(filters)

List NFT holdings.

```javascript
const nfts = await client.listNFTs({ collection: 'opensea' });
```

---

#### getMarketData(symbol)

Get market data.

```javascript
const data = await client.getMarketData('AAPL');
```

---

#### runAIAnalysis(analysisType, options)

Run AI-powered analysis.

```javascript
const result = await client.runAIAnalysis('trend-analysis', {
  symbols: ['AAPL', 'MSFT'],
});
```

---

## License

MIT
npm package: @orchestree/onboarding
Description: Onboarding module — Setup wizards, interactive feature tours, template gallery
Author: Orchestree
Latest version: 1.2.0

# @orchestree/onboarding

User onboarding and guided tours for Orchestree. Create onboarding wizards, interactive tours, and track user progress.

## Installation

```bash
npm install @orchestree/onboarding
```

## Quick Start

```javascript
const { OnboardingClient } = require('@orchestree/onboarding');

const client = new OnboardingClient({
  apiKey: 'your-api-key',
});

// Create onboarding wizard
const wizard = await client.createWizard({
  name: 'Product Setup',
  steps: [
    { title: 'Welcome', description: 'Get started', order: 1 },
    { title: 'Configuration', description: 'Configure your account', order: 2 },
    { title: 'Invite Team', description: 'Add team members', order: 3 },
  ],
});

// Start tour
await client.startTour('user-123', wizard.id);

// Track progress
await client.trackProgress('user-123', 'step-1');

// Get user progress
const progress = await client.getUserProgress('user-123');
```

## API Reference

### OnboardingClient

#### createWizard(wizardDef)

Create an onboarding wizard.

```javascript
const wizard = await client.createWizard({
  name: 'Getting Started',
  steps: [
    { title: 'Step 1', description: 'First step', order: 1 },
    { title: 'Step 2', description: 'Second step', order: 2 },
  ],
});
```

---

#### startTour(userId, tourId)

Start a guided tour for a user.

```javascript
await client.startTour('user-123', 'tour-456');
```

---

#### trackProgress(userId, stepId)

Track user progress on a step.

```javascript
const progress = await client.trackProgress('user-123', 'step-1');
```

---

#### getCompletionRate(wizardId)

Get wizard completion statistics.

```javascript
const stats = await client.getCompletionRate(wizard.id);
```

---

## License

MIT
npm package: @orchestree/projects
Description: Projects module — Kanban boards, timeline/Gantt, sprints, workflow automation
Author: Orchestree
Latest version: 1.4.0

# @orchestree/projects

Project management and task tracking for Orchestree. Create projects, manage tasks, run sprints, and automate workflows.

## Installation

```bash
npm install @orchestree/projects
```

## Quick Start

```javascript
const { ProjectsClient } = require('@orchestree/projects');

const client = new ProjectsClient({
  apiKey: 'your-api-key',
});

// Create a project
const project = await client.createProject({
  name: 'Mobile App',
  description: 'iOS and Android release',
});

// Create tasks
const task = await client.createTask(project.id, {
  title: 'Design wireframes',
  priority: 'high',
  assignee: 'designer@example.com',
});

// Create sprint
const sprint = await client.createSprint(project.id, {
  name: 'Sprint 1',
  startDate: '2024-04-15',
  endDate: '2024-04-28',
});

// Get board view
const board = await client.getBoard(project.id);
```

## API Reference

### ProjectsClient

#### createProject(projectDef)

Create a new project.

```javascript
const project = await client.createProject({
  name: 'Website Redesign',
  description: 'Q2 initiative',
});
```

---

#### createTask(projectId, taskDef)

Create a task in a project.

```javascript
const task = await client.createTask(project.id, {
  title: 'Homepage mockup',
  priority: 'high',
  dueDate: '2024-04-20',
});
```

---

#### moveTask(taskId, status)

Move task to a different status.

```javascript
await client.moveTask(task.id, 'in-progress');
```

---

#### createSprint(projectId, sprintDef)

Create a sprint.

```javascript
const sprint = await client.createSprint(project.id, {
  name: 'Sprint 2',
  startDate: '2024-05-01',
  endDate: '2024-05-14',
});
```

---

## License

MIT
npm package: @orchestree/scheduling
Description: Scheduling module — Calendar views, booking pages, team scheduling, availability
Author: Orchestree
Latest version: 1.2.0

# @orchestree/scheduling

Calendar and booking management for Orchestree. Schedule events, find availability, and manage bookings across multiple calendars.

## Installation

```bash
npm install @orchestree/scheduling
```

## Quick Start

```javascript
const { SchedulingClient } = require('@orchestree/scheduling');

const client = new SchedulingClient({
  apiKey: 'your-api-key',
});

// Create event
const event = await client.createEvent({
  title: 'Team Standup',
  startTime: '2024-04-15T10:00:00Z',
  endTime: '2024-04-15T10:30:00Z',
  attendees: ['team@example.com'],
});

// Check availability
const availability = await client.getAvailability('user-123', {
  startDate: '2024-04-15',
  endDate: '2024-04-20',
});

// Create booking page
const bookingPage = await client.createBookingPage({
  title: 'One-on-One',
  duration: 30,
});
```

## API Reference

### SchedulingClient

#### createEvent(eventDef)

Create a calendar event.

```javascript
const event = await client.createEvent({
  title: 'Meeting',
  startTime: '2024-04-15T14:00:00Z',
  endTime: '2024-04-15T15:00:00Z',
  attendees: ['attendee@example.com'],
});
```

---

#### getAvailability(userId, dateRange)

Get user availability.

```javascript
const availability = await client.getAvailability('user-123', {
  startDate: '2024-04-15',
  endDate: '2024-04-22',
});
```

---

#### createBookingPage(bookingDef)

Create a booking page.

```javascript
const page = await client.createBookingPage({
  title: 'Consultation',
  duration: 60,
});
```

---

#### findFreeSlots(userId, duration, dateRange)

Find available time slots.

```javascript
const slots = await client.findFreeSlots('user-123', 30, {
  startDate: '2024-04-15',
  endDate: '2024-04-22',
});
```

---

## License

MIT
npm package: @orchestree/settings
Description: Settings module — Account management, billing, security preferences, appearance
Author: Orchestree
Latest version: 1.2.0

# @orchestree/settings

Account and security settings management for Orchestree. Manage user preferences, billing, security, and account settings.

## Installation

```bash
npm install @orchestree/settings
```

## Quick Start

```javascript
const { SettingsClient } = require('@orchestree/settings');

const client = new SettingsClient({
  apiKey: 'your-api-key',
});

// Get settings
const settings = await client.getSettings();

// Update settings
await client.updateSettings({
  timezone: 'America/New_York',
  theme: 'dark',
});

// Get billing info
const billing = await client.getBilling();

// Enable 2FA
await client.enable2FA('authenticator');

// Get security log
const logs = await client.getSecurityLog({ limit: 50 });
```

## API Reference

### SettingsClient

#### getSettings()

Get account settings.

```javascript
const settings = await client.getSettings();
```

---

#### updateSettings(updates)

Update account settings.

```javascript
await client.updateSettings({
  timezone: 'Europe/London',
  language: 'en',
});
```

---

#### getBilling()

Get billing information.

```javascript
const billing = await client.getBilling();
```

---

#### updateBilling(billingInfo)

Update billing information.

```javascript
await client.updateBilling({
  paymentMethod: 'card-123',
});
```

---

#### getSecurityLog(filters)

Get security log entries.

```javascript
const logs = await client.getSecurityLog({
  days: 30,
  action: 'login',
});
```

---

#### enable2FA(method)

Enable two-factor authentication.

```javascript
await client.enable2FA('authenticator');
```

---

#### changePassword(oldPassword, newPassword)

Change account password.

```javascript
await client.changePassword('oldPass123', 'newPass456');
```

---

## License

MIT
npm package: @orchestree/social
Description: Social module — Multi-platform content calendar, posting, analytics, audience insights
Author: Orchestree
Latest version: 1.4.0

# @orchestree/social

AI-powered social media management and content generation for Orchestree. Create, schedule, and analyze social content across multiple platforms.

## Installation

```bash
npm install @orchestree/social
```

## Quick Start

```javascript
const { SocialClient } = require('@orchestree/social');

const client = new SocialClient({
  apiKey: 'your-api-key',
});

// Generate content
const content = await client.generateContent('AI trends 2024', {
  style: 'professional',
  length: 'medium',
});

// Create and schedule post
const post = await client.createPost(content.content);
await client.schedulePost(post.id, '2024-04-15T09:00:00Z', ['twitter', 'linkedin']);

// Get analytics
const analytics = await client.getAnalytics({
  startDate: '2024-04-01',
  endDate: '2024-04-30',
});
```

## API Reference

### SocialClient

#### Constructor

```javascript
new SocialClient(config)
```

**Config:**
- `apiKey` (string, required): Your API key
- `baseURL` (string, optional): API base URL

#### Methods

##### generateContent(topic, options)

Generate AI-powered content.

```javascript
const content = await client.generateContent('Product launch', {
  style: 'engaging',
  tone: 'professional',
  keywords: ['innovation', 'technology'],
});
```

---

##### createPost(content, metadata)

Create a new post.

```javascript
const post = await client.createPost('Check out our new feature!', {
  hashtags: ['#feature', '#launch'],
});
```

---

##### schedulePost(postId, scheduleTime, platforms)

Schedule a post for publishing.

```javascript
await client.schedulePost(post.id, '2024-04-15T09:00:00Z', ['twitter', 'linkedin']);
```

---

##### getCalendar(options)

Get calendar view of scheduled posts.

```javascript
const calendar = await client.getCalendar({
  month: 'April',
  year: 2024,
});
```

---

##### getAnalytics(timeRange)

Get analytics data.

```javascript
const analytics = await client.getAnalytics({
  startDate: '2024-04-01',
  endDate: '2024-04-30',
});
```

---

##### connectPlatform(platformName, credentials)

Connect a social media platform.

```javascript
await client.connectPlatform('twitter', {
  token: 'your-token',
  secret: 'your-secret',
});
```

---

##### listPlatforms()

List all connected platforms.

```javascript
const platforms = await client.listPlatforms();
```

---

##### publishPost(postId, platforms)

Publish a post immediately.

```javascript
await client.publishPost(post.id, ['twitter', 'facebook']);
```

---

##### getPostMetrics(postId)

Get metrics for a specific post.

```javascript
const metrics = await client.getPostMetrics(post.id);
```

---

##### getAudienceInsights()

Get audience insights.

```javascript
const insights = await client.getAudienceInsights();
```

---

## License

MIT