open-index/open-npm huggingface dataset:
npm package: @quave/eslint-config-quave
Description: ESLint configurations used by Quave for JavaScript projects
Author: Filipe Nevola
Latest version: 3.0.1

# @quave/eslint-config-quave

[![npm version](https://badge.fury.io/js/@quave%2Feslint-config-quave.svg)](https://badge.fury.io/js/@quave%2Feslint-config-quave)

`@quave/eslint-config-quave` is a group of eslint and prettier configurations to make your Meteor application organized in a standard way.

## Why

We believe applications should be organized and checked before every commit.

We believe we are not reinventing the wheel in this package but what we are doing is like putting together the wheels in the vehicle :).

## Installation

Install the npm dependency
```sh
npm i -D @quave/eslint-config-quave
```

Add to the root of your package.json

```json
  "eslintConfig": {
    "extends": [
      "@quave/quave"
    ]
  },
```

Create in the root of your project `prettier.config.js` file and paste this

```javascript
module.exports = require('@quave/eslint-config-quave/prettier.config');
```

Create in the root of your project `.prettierignore` file and paste this

`.meteor`

### Script examples

Set the custom commands if you want to run eslint or prettier manually or both. Add this to your `package.json`
```json
  {
    "scripts": {
      "quave-eslint": "eslint . --fix",
      "quave-prettier": "prettier --write \"**/*.js\"",
      "quave-check": "npm run quave-eslint && npm run quave-prettier"
    }
  }
```

If you have jsx files as well, you can use:
```json
  "quave-prettier": "prettier --write \"**/*.js\" \"**/*.jsx\"",
```

## Automatic check before commit

Automatic check your changed files before every commit.

Install lefthook:

```bash
npm i -D lefthook
```

then create a file called `lefthook.yml` in the root of your project and paste this:

```yaml
pre-commit:
  commands:
    quave-check:
      run: npm run quave-check
    update-index:
      run: git update-index --again
 ```

> In the past we used husky but lefthook is much better in terms of dependency and speed.

## Limitations

We consider an error `console.log` but in some cases you want to use it, then you should disable for the next line and use it.
```javascript
// eslint-disable-next-line no-console
console.log('Important log...');
```

### License

MIT
npm package: @quave/eslint-plugin-meteor-quave
Description: Quave linting rules for ESLint
Latest version: 1.5.3

# @quave/eslint-plugin-meteor-quave

[![npm version](https://badge.fury.io/js/@quave%2Feslint-plugin-meteor-quave.svg)](https://badge.fury.io/js/@quave%2Feslint-plugin-meteor-quave)

`@quave/eslint-plugin-meteor-quave` is a plugin for eslint to ensure Javascript and Meteor standards.

## Why
This plugin will help you with your Meteor 3.0 migration.

## Installation

We recommend you to use this plugin via [quave-eslint-config](https://github.com/quavedev/eslint-config) but you can also install it directly.

Install the npm dependency
```sh
npm i -D @quave/eslint-plugin-meteor-quave
```

## Debug

You can debug by providing the `METEOR_ESLINT_PLUGIN_DEBUG` env var as `1` for example, so you will see more logs.

Run your eslint task like: `METEOR_ESLINT_PLUGIN_DEBUG=1 eslint .`

## Options

- Env var `METEOR_ESLINT_PLUGIN_EXPIRES_CACHE_IN_SECONDS`: default is `5`. You can customize the cache expiration time in seconds. - **This is especially important if you have a big project with several files and it takes a lot of time to analyze. If this value is too low, the cache will expire while the analysis is running, and the lint won´t work.**
- Env var `METEOR_ESLINT_PLUGIN_DEBUG`: default is disabled. You can pass this to enable debug mode and see more logs.
- Env var `METEOR_ESLINT_PLUGIN_IGNORE_CACHE`: default is false. You can pass this to ignore the cache.
- Env var `METEOR_ESLINT_PLUGIN_FILES`: use this if you want to lint a specific file.

## Changelog

[CHANGELOG](./CHANGELOG.md)

## License

MIT
npm package: @quave/mup-aws-beanstalk
Description: Deploy apps to AWS Elastic Beanstalk using Meteor Up
Author: zodern
Latest version: 0.8.0

## mup-aws-beanstalk

Plugin for Meteor Up to deploy using AWS Beanstalk.

Features:
- Load balancing with support for sticky sessions and web sockets
- Autoscaling
- Meteor settings.json
- Zero downtime deploys
- Automatically uses the correct node version

[Getting Started Guide](./docs/getting-started.md)

[Documentation](./docs/index.md)
npm package: @quave/performance-audit
Description: Easily check the performance of a web address according to Google's Lighthouse and compare with an expected baseline.
Author: Quave
Latest version: 1.0.5

# Performance Audit by Quave

Easily check the performance of a web address according to Google's PageSpeed and compare with an expected baseline. To know more about the scores, see https://developers.google.com/web/tools/lighthouse.
This test is designed to run on a CI to monitor the scores over time and notify when a regression occurs.

## Installation

`npm install @quave/performance-audit`

## How to use

Pass a array of tests to the `checkPerformance` function.

Test object structure:
- `url`: The link to test
- `stategy`: Should be `desktop` or `mobile`
- `threshold`: How much the results need to differ to trigger a fail 
- `pwa`, `bestPractices`, `accessibility`, `seo`, `performance`: Scores baselines for the tests (optional)
- `appJsTransferSize`, `appCssTransferSize`: Sizes baselines of the js and css bundles (optional)
- `jsIdentifier`, `cssIdentifier`: String used to identify your app's bundle. (required if using `appJsTransferSize` or `appCssTrasnferSize`)

Additionally, you may pass a `options` as a second argument, to use values commom for all tests.

#### Example
```js
// Example file app.slow.test.js
import { checkPerformance } from "@quave/performance-audit";

checkPerformance({
  applications: [
    {
      url: "https://www.meteor.com",
      strategy: "desktop",
      pwa: 0.69,
      bestPractices: 0.77,
      accessibility: 0.55,
      seo: 0.6,
      performance: 0.2,
      appJsTransferSize: 2168542,
      appCssTransferSize: 4513,
    },
  ],
  options: {
    threshold: 0.95,
    jsIdentifier: '.js?meteor_js_resource=true',
    cssIdentifier: '.css?meteor_css_resource=true',
  },
)
```

## Jest
The library uses jest to run the test. It is set as a peer dependency, so you may choose which
version to install.

## Slow tests
This test usually takes several seconds to complete, and that is not great. We recommend creating a new test group e.g. _slow_ group:

```js
//File jest.slow.config.js
module.exports = {
  ...
  testRegex: '(/__tests__/.*|(\\.|/)(slow\\.test))\\.jsx?$',
  ...
};
```

And then creating the performance tests in a file with the suffix `slow.test.js`.
These tests then can be executed by calling `jest -c jest.slow.config.js`.
npm package: @quazardous/quarkernel-react
Description: React bindings for QuarKernel - Context provider and hooks
Author: quazardous
Latest version: 2.2.2

# @quazardous/quarkernel-react

React 18+ bindings for QuarKernel - Context provider and hooks with auto-cleanup.

## Installation

```bash
npm install @quazardous/quarkernel @quazardous/quarkernel-react
```

## Features

- **KernelProvider**: Context provider for dependency injection
- **useKernel()**: Access kernel anywhere in tree
- **useOn()**: Register listener with auto-cleanup on unmount
- **useEventState()**: Reactive state from events
- **Type-safe**: Full TypeScript support
- **SSR-safe**: Warns on server-side access

## Usage

### Basic Setup

```tsx
import { createKernel } from '@quazardous/quarkernel';
import { KernelProvider } from '@quazardous/quarkernel-react';

const qk = createKernel();

function App() {
  return (
    <KernelProvider kernel={kernel}>
      <MyComponent />
    </KernelProvider>
  );
}
```

### useKernel()

Access kernel instance from any component:

```tsx
import { useKernel } from '@quazardous/quarkernel-react';

function MyComponent() {
  const qk = useKernel();

  const handleClick = () => {
    qk.emit('button:clicked', { timestamp: Date.now() });
  };

  return <button onClick={handleClick}>Click me</button>;
}
```

### useOn()

Register listener with automatic cleanup on unmount:

```tsx
import { useOn } from '@quazardous/quarkernel-react';

function Notifications() {
  useOn('notification:new', (event) => {
    console.log('New notification:', event.data);
  });

  // Listener auto-removed when component unmounts
  return <div>Listening for notifications...</div>;
}
```

### useEventState()

Reactive state derived from events:

```tsx
import { useEventState } from '@quazardous/quarkernel-react';

function Counter() {
  const count = useEventState('counter:updated', 0, (event) => event.data.value);

  return <div>Count: {count}</div>;
}
```

### Wildcard Patterns

```tsx
import { useOn } from '@quazardous/quarkernel-react';

function UserTracker() {
  useOn('user:*', (event) => {
    console.log('User event:', event.name, event.data);
  });

  return null;
}
```

## API

### `<KernelProvider kernel={kernel}>`

Context provider for kernel instance.

**Props:**
- `kernel`: Kernel instance (required)
- `children`: React children

### `useKernel()`

Hook to access kernel from context.

**Returns:** Kernel instance

**Throws:** `KernelProviderError` if used outside provider

### `useOn(event, handler, options?)`

Register event listener with auto-cleanup.

**Parameters:**
- `event`: Event name or wildcard pattern
- `handler`: `(event, ctx) => void | Promise<void>`
- `options`: Listener options (id, after, priority)

**Returns:** Unsubscribe function

### `useEventState(event, initial, selector?)`

Reactive state from events.

**Parameters:**
- `event`: Event name to listen for
- `initial`: Initial state value
- `selector`: Optional `(event) => T` to extract value

**Returns:** Current state value

## License

MIT
npm package: @quazardous/quarkernel-svelte
Description: Svelte 5 adapter for QuarKernel - event kernel integration with Svelte context
Author: quazardous
Latest version: 2.2.2

# @quazardous/quarkernel-svelte

Svelte 5 adapter for QuarKernel - context API and composables for seamless event kernel integration.

## Installation

```bash
npm install @quazardous/quarkernel @quazardous/quarkernel-svelte
```

## Features

- **Context API**: `setKernel()`/`getKernel()` for dependency injection
- **Auto-cleanup**: `onEvent()` composable with automatic unsubscribe on destroy
- **Type-safe**: Full TypeScript support
- **Svelte 5**: Designed for Svelte 5+ with modern context system
- **Zero runtime deps**: Only peer dependencies on Svelte and QuarKernel

## Usage

### Basic Setup

```svelte
<!-- App.svelte (root component) -->
<script>
  import { createKernel } from '@quazardous/quarkernel';
  import { setKernel } from '@quazardous/quarkernel-svelte';

  const qk = createKernel();
  setKernel(kernel);
</script>

<ChildComponent />
```

### Using in Child Components

```svelte
<!-- ChildComponent.svelte -->
<script>
  import { getKernel, onEvent } from '@quazardous/quarkernel-svelte';

  // Get kernel from context
  const qk = getKernel();

  // Register listener with auto-cleanup
  onEvent('user:login', async (event) => {
    console.log('User logged in:', event.data);
  });

  // Manual emit
  function handleClick() {
    qk.emit('button:clicked', { timestamp: Date.now() });
  }
</script>

<button on:click={handleClick}>Click me</button>
```

### Wildcard Patterns

```svelte
<script>
  import { onEvent } from '@quazardous/quarkernel-svelte';

  // Listen to all user events
  onEvent('user:*', (event) => {
    console.log('User event:', event);
  });
</script>
```

### Manual Cleanup

```svelte
<script>
  import { onEvent } from '@quazardous/quarkernel-svelte';

  // onEvent returns unsubscribe function
  const unsubscribe = onEvent('temp:event', (event) => {
    console.log('Temporary listener');
  });

  function cleanup() {
    unsubscribe(); // Remove listener before component destroys
  }
</script>
```

## API

### `setKernel(kernel)`

Store kernel instance in Svelte context. Must be called during component initialization.

**Parameters:**
- `kernel`: Kernel instance to provide to child components

**Throws:**
- Error if kernel is null/undefined

### `getKernel()`

Retrieve kernel instance from Svelte context.

**Returns:**
- Kernel instance

**Throws:**
- `KernelContextError` if called outside context or before `setKernel()`

### `onEvent(pattern, handler)`

Register event listener with automatic cleanup on component destroy.

**Parameters:**
- `pattern`: Event name or wildcard pattern (e.g., `'user:*'`)
- `handler`: Event handler function `(event, ctx) => void | Promise<void>`

**Returns:**
- Unsubscribe function for manual cleanup

**Throws:**
- `KernelContextError` if kernel not in context

## License

MIT
npm package: @quazardous/quarkernel-vue
Description: Vue 3 adapter for QuarKernel - event kernel integration with Vue reactivity
Author: quazardous
Latest version: 2.2.2

# @quazardous/quarkernel-vue

Vue 3 adapter for QuarKernel - seamless event kernel integration with Vue's reactivity system.

## Installation

```bash
npm install @quazardous/quarkernel @quazardous/quarkernel-vue
# or
pnpm add @quazardous/quarkernel @quazardous/quarkernel-vue
```

## Usage

### 1. Install the Plugin

```typescript
import { createApp } from 'vue';
import { createKernel } from '@quazardous/quarkernel';
import { QuarKernelPlugin } from '@quazardous/quarkernel-vue';
import App from './App.vue';

const qk = createKernel();
const app = createApp(App);

app.use(QuarKernelPlugin, { kernel });
app.mount('#app');
```

### 2. Use in Components

```vue
<script setup lang="ts">
import { useKernel } from '@quazardous/quarkernel-vue';
import { onMounted } from 'vue';

const qk = useKernel();

onMounted(() => {
  qk.on('user:login', async (event) => {
    console.log('User logged in:', event.data);
  });
});

async function login() {
  await qk.emit('user:login', { userId: '123' });
}
</script>
```

## API

### QuarKernelPlugin

Vue plugin that registers the kernel instance globally.

**Options:**
- `kernel`: Kernel instance to provide globally (required)

### useKernel()

Composable to access the kernel instance from within component setup functions.

**Returns:** The kernel instance provided via the plugin

**Throws:**
- Error if called outside setup() context
- Error if plugin not installed

**SSR Warning:** Warns when accessed during server-side rendering

## TypeScript Support

Full TypeScript support with typed events:

```typescript
interface AppEvents {
  'user:login': { userId: string };
  'user:logout': { userId: string };
}

const qk = createKernel<AppEvents>();

// In component
const qk = useKernel<typeof kernel>();
```

## License

MIT
npm package: @quazex/eslint-config
Description: Custom eslint config for organization packages
Author: Alexander Smirnov
Latest version: 1.1.4

# Custom ESLint Configuration

This package provides a custom ESLint configuration for TypeScript projects, ensuring consistent code quality and best practices.

## Features

- Predefined rules for TypeScript
- Optimized for NestJS and Node.js projects
- Support Stylistic for code formatting
- Extends some popular ESLint configurations
- Easy to integrate and customize

## Installation

```sh
npm install --save-dev @quazex/eslint-config
```

## Usage

Create an `.eslintrc.json` file in the root of your project and extend this configuration:

```js
import quazexConfig from '@quazex/eslint-config'

export default [
  ...quazexConfig,
]
```

Overrides

You can override any predefined rule in the config, for example:

```js
import quazexConfig from '@quazex/eslint-config'

export default [
  ...quazexConfig,
  {
    rules: {
      'init-declarations': 'off',
    }
  }
]
```

## License

MIT
npm package: @quazex/nestjs-ioredis
Description: NestJS module for ioredis library
Author: Alexander Smirnov
Latest version: 1.4.0

# NestJS ioredis module

Core features:

- Based on [official ioredis client for NodeJS](https://github.com/redis/ioredis);
- Includes standalone and cluster clients;
- Covered with unit and e2e tests;
- Basic module without unnecessary boilerplate.

## Installation

To install the package, run:

```sh
npm install @quazex/nestjs-ioredis ioredis
```

## Usage

### Importing the Module

To use the ioredis module in your NestJS application, import it into your root module (e.g., `AppModule`).

```typescript
import { Module } from '@nestjs/common';
import { RedisClientModule } from '@quazex/nestjs-ioredis';

@Module({
    imports: [
        RedisClientModule.forRoot({
            url: 'redis://localhost:6379/1',
        }),
    ],
})
export class AppModule {}
```

### Using ioredis Service

Once the module is registered, you can inject instance of the `Redis` or `Cluster` into your providers:

```typescript
import { Injectable } from '@nestjs/common';
import { InjectRedisClient } from '@quazex/nestjs-ioredis/client';
import { Redis } from 'ioredis';

@Injectable()
export class StorageService {
    constructor(@InjectRedisClient() private readonly client: Redis) {}

    async write(key: string, value: object) {
        await this.client.set(key, value);
    }

    async read(key: string) {
        return this.client.get(key);
    }
}
```

### Async Configuration

If you need dynamic configuration, use `forRootAsync`:

```typescript
@Module({
    imports: [
        RedisClientModule.forRootAsync({
            useFactory: async (config: SomeConfigProvider) => ({
                url: config.REDIS_URL,
            }),
            inject: [
                SomeConfigProvider,
            ],
        }),
    ],
})
export class AppModule {}
```

### Connection and graceful shutdown

You need to enable shutdown hooks to activate connection management when the application is shut down. You can read more about lifecycle hooks on the NestJS [documentation page](https://docs.nestjs.com/fundamentals/lifecycle-events#application-shutdown).

```typescript
// main.ts
const app = await NestFactory.create(AppModule);

// Starts listening for shutdown hooks
app.enableShutdownHooks(); // <<<

await app.listen(process.env.PORT ?? 3000);
```

## License

MIT
npm package: @quazex/nestjs-opensearch
Description: NestJS module for OpenSearch client
Author: Alexander Smirnov
Latest version: 1.3.0

# NestJS OpenSearch Module

Core features:

- Based on [official OpenSearch client for NodeJS](https://github.com/opensearch-project/opensearch-js);
- Covered with unit and e2e tests;
- Basic module without unnecessary boilerplate.

## Installation

To install the package, run:

```sh
npm install @quazex/nestjs-opensearch @opensearch-project/opensearch
```

## Usage

### Importing the Module

To use the OpenSearch module in your NestJS application, import it into your root module (e.g., `AppModule`).

```typescript
import { Module } from '@nestjs/common';
import { OpenSearchModule } from '@quazex/nestjs-opensearch';

@Module({
  imports: [
    OpenSearchModule.forRoot({
      node: 'https://localhost:9200',
      auth: {
        username: 'your-username',
        password: 'your-password',
      },
    }),
  ],
})
export class AppModule {}
```

### Using OpenSearch Service

Once the module is registered, you can inject instance of `Client` into your providers:

```typescript
import { Injectable } from '@nestjs/common';
import { Client } from '@opensearch-project/opensearch';
import { InjectOpenSearch } from '@quazex/nestjs-opensearch';

@Injectable()
export class SearchService {
  private readonly INDEX_NAME = 'search_index'

  constructor(@InjectOpenSearch() private readonly client: Client) {}

  async createIndex(body: any) {
    return this.client.indices.create({
      index: this.INDEX_NAME,
      body,
    });
  }

  async indexDocument(id: string, body: any) {
    return this.client.index({
      index: this.INDEX_NAME,
      id,
      body,
    });
  }

  async search(query: any) {
    return this.client.search({
      index: this.INDEX_NAME,
      body: query,
    });
  }
}
```

### Async Configuration

If you need dynamic configuration, use `forRootAsync`:

```typescript
import { Module } from '@nestjs/common';
import { OpenSearchModule } from '@quazex/nestjs-opensearch';

@Module({
  imports: [
    OpenSearchModule.forRootAsync({
      useFactory: async (config: SomeConfigProvider) => ({
        node: config.OPENSEARCH_NODE,
        auth: {
          username: config.OPENSEARCH_USERNAME,
          password: config.OPENSEARCH_PASSWORD,
        },
      }),
      inject: [
        SomeConfigProvider,
      ],
    }),
  ],
})
export class AppModule {}
```

### Graceful shutdown

By default, this module doesn't manage client connection on application shutdown. You can read more about lifecycle hooks on the NestJS [documentation page](https://docs.nestjs.com/fundamentals/lifecycle-events#application-shutdown).

```typescript
// main.ts
const app = await NestFactory.create(AppModule);

// Starts listening for shutdown hooks
app.enableShutdownHooks(); // <<<

await app.listen(process.env.PORT ?? 3000);
```

## License

MIT
npm package: @quazex/nestjs-postgres
Description: NestJS module for Postgres library
Author: Alexander Smirnov
Latest version: 1.0.1

# NestJS Postgres Module

Core features:

- Based on [postgres library for NodeJS](https://github.com/porsager/postgres);
- Covered with unit and e2e tests;
- Basic module without unnecessary boilerplate.

## Installation

```sh
npm install @quazex/nestjs-postgres postgres
```

## Usage

### Importing the Module

```typescript
import { Module } from '@nestjs/common';
import { PostgresModule } from '@quazex/nestjs-postgres';

@Module({
  imports: [
    PostgresModule.forRoot({
      host: 'localhost',
      port: 5432,
      user: 'test',
      password: 'test',
      database: 'test',
    }),
  ],
})
export class AppModule {}
```

### Injecting the Client

```typescript
import { Injectable } from '@nestjs/common';
import { InjectPostgres } from '@quazex/nestjs-postgres';
import type { Sql } from 'postgres';

@Injectable()
export class DatabaseService {
  constructor(@InjectPostgres() private readonly sql: Sql) {}

  async insert(document: object) {
    await this.sql`INSERT INTO table ${this.sql(document)}`;
  }

  async select(id: string) {
    const [row] = await this.sql`SELECT * FROM table WHERE id = ${id}`;
    return row;
  }
}
```

### Async Configuration

```typescript
import { Module } from '@nestjs/common';
import { PostgresModule } from '@quazex/nestjs-postgres';

@Module({
  imports: [
    PostgresModule.forRootAsync({
      useFactory: (config: SomeConfigProvider) => ({
        host: config.PG_HOST,
        port: config.PG_PORT,
        user: config.PG_USER,
        password: config.PG_PASSWORD,
        database: config.PG_DATABASE,
      }),
      inject: [
        SomeConfigProvider,
      ],
    }),
  ],
})
export class AppModule {}
```

### Connection and graceful shutdown

By default, this module doesn't manage the client connection on application shutdown. You can read more about lifecycle hooks on the NestJS [documentation page](https://docs.nestjs.com/fundamentals/lifecycle-events#application-shutdown).

```typescript
// main.ts
const app = await NestFactory.create(AppModule);

app.enableShutdownHooks();

await app.listen(process.env.PORT ?? 3000);
```

```typescript
// app.bootstrap.ts
import { Injectable, OnApplicationShutdown } from '@nestjs/common';
import { InjectPostgres } from '@quazex/nestjs-postgres';
import type { Sql } from 'postgres';

@Injectable()
export class AppBootstrap implements OnApplicationShutdown {
  constructor(@InjectPostgres() private readonly sql: Sql) {}

  public async onApplicationShutdown(): Promise<void> {
    await this.sql.end();
  }
}
```

## License

MIT
npm package: @quba/sensitive-data-protection
Description: SDK for Sensitive Data Protection Service
Author: Quba Ltd
Latest version: 0.0.8

# @quba/sensitive-data-protection

A TypeScript SDK client for the app.quba.ae API.

## Usage

First, install the SDK from npm.

```bash
npm install @quba/sensitive-data-protection --save
```

Next, try it out.


```ts
import {
  Configuration,
  SensitiveDataProtectionApi,
} from '@quba/sensitive-data-protection';
import type { AnonymizeTextRequest } from '@quba/sensitive-data-protection';

async function example() {
  console.log("🚀 Testing @quba/sensitive-data-protection SDK...");
  const api = new SensitiveDataProtectionApi();

  const body = {
    // AnonymizeRequestBody
    AnonymizeRequestBody: ...,
  } satisfies AnonymizeTextRequest;

  try {
    const data = await api.anonymizeText(body);
    console.log(data);
  } catch (error) {
    console.error(error);
  }
}

// Run the test
example().catch(console.error);
```


## Documentation

### API Endpoints

All URIs are relative to *https://app.quba.ae/api/sdp*

| Class | Method | HTTP request | Description
| ----- | ------ | ------------ | -------------
*SensitiveDataProtectionApi* | [**anonymizeText**](docs/SensitiveDataProtectionApi.md#anonymizetext) | **POST** /anonymize | Anonymize Text
*SensitiveDataProtectionApi* | [**healthCheck**](docs/SensitiveDataProtectionApi.md#healthcheck) | **GET** /health | Health
*SensitiveDataProtectionApi* | [**scanText**](docs/SensitiveDataProtectionApi.md#scantext) | **POST** /scan | Scan Text


### Models

- [AnonymizeRequestBody](docs/AnonymizeRequestBody.md)
- [AnonymizeRequestBodyRulesInner](docs/AnonymizeRequestBodyRulesInner.md)
- [AnonymizeResponseBody](docs/AnonymizeResponseBody.md)
- [AnonymizeResponseBodyResultsInner](docs/AnonymizeResponseBodyResultsInner.md)
- [EncryptRule](docs/EncryptRule.md)
- [Entities](docs/Entities.md)
- [EntitiesAnyOfInner](docs/EntitiesAnyOfInner.md)
- [HTTPValidationError](docs/HTTPValidationError.md)
- [MaskRule](docs/MaskRule.md)
- [ModelEntity](docs/ModelEntity.md)
- [ModelResult](docs/ModelResult.md)
- [RedactRule](docs/RedactRule.md)
- [RegexEntity](docs/RegexEntity.md)
- [RegexResult](docs/RegexResult.md)
- [ReplaceRule](docs/ReplaceRule.md)
- [SHA256Rule](docs/SHA256Rule.md)
- [SHA512Rule](docs/SHA512Rule.md)
- [ScanRequestBody](docs/ScanRequestBody.md)
- [ScanResponseBody](docs/ScanResponseBody.md)
- [ScanResult](docs/ScanResult.md)
- [TextRange](docs/TextRange.md)
- [ValidationError](docs/ValidationError.md)
- [ValidationErrorLocInner](docs/ValidationErrorLocInner.md)