open-index/open-npm huggingface dataset:
npm package: @gthole/simpleagent
Description: A NodeJS simplified version of SuperAgent.js for making JSON HTTP requests
Author: gthole@gmail.com
Latest version: 1.0.1
Deprecated: WARNING: This project has been renamed to 'simpleragent'.  Please install using 'simpleragent' instead.

# SimpleAgent
A NodeJS simplified version of [SuperAgent.js](http://visionmedia.github.io/superagent/)
for making JSON HTTP requests.

### Why?
Superagent is great!  It lets you structure your requests cleanly and programmatically.

But it's also pretty heavy - it contains lots of features that aren't necessary
for making simple JSON requests, which are most of the requests I make most of
the time.  If I'm bundling up a small Lambda function, it's better to have a
super small library to provide the same functionality without all the extra
stuff.

**SimpleAgent:**
- Can probably do most of what you need for API requests
- Has no production dependencies
- Is small: roughly 100 lines of code
- Is typed with Typescript
- Has good test coverage

### Installation

Easy enough:

```bash
$ npm install --save @gthole/simpleagent
```

### What's Supported?
Basic JSON requests work just fine:

```javascript
const request = require('@gthole/simpleagent');

// Auth and query strings
request
    .get('http://www.example.com')
    .auth('my-user', 'pass')
    .query({name: 'bananas'})
    .end((err, resp) => {
        // Do something
    });

// Promises, within an async function
const resp = await request
    .get('http://www.example.com/foo?bar=baz')
    .promise();

// Sending JSON bodies, HTTPS, and setting headers
request
    .post('https://api.example.com/v1/fruit')
    .set('Authorization', 'Bearer ' + myApiKey)
    .send({name: 'banana', type: 'peel'})
    .then((resp) => {
        // Do something
    });
```

### What Isn't Supported?
Everything else.

**Features that are left out:**
- Content-Types besides JSON: no `type`, `accept` or `serialize` methods.
- Piping response data: Data loaded directly into memory
- Sessions: Cookies not saved
- Progress Tracking: Don't use it for big uploads
- Browser version: Node only
- Retrying request: Do that manually if you want it
- TLS options: Maybe will add these later
- Aborts / Timeouts
- Following Redirects
- Plugins, etc.
npm package: @gthos/cli
Description: GroundTruth OS CLI — connect your AI agents to a canonical knowledge base
Latest version: 0.11.0

# @gthos/cli

Connect your AI agents to a [GroundTruth OS](https://groundtruthos.ai) canonical knowledge base.

## Quick Start

```bash
npx @gthos/cli init
```

This detects your coding agents (Claude Code, Cursor, VS Code Copilot, Windsurf) and configures them to use your GroundTruth OS workspace as their source of truth.

### What `gthos init` does

- Detects which AI coding platforms are in your project
- Writes MCP server config for each detected platform
- Creates an `AGENTS.md` with your canonical doc inventory and agent instructions
- Appends a GroundTruth OS reference to `CLAUDE.md` (if present)
- Installs Claude Code skills for reading/updating your knowledge base
- Verifies the MCP connection works

## Authentication

```bash
gthos auth login          # Browser-based login
gthos init --key <key>    # Or pass an API key directly
```

## Commands

| Command | Description |
|---------|-------------|
| `gthos init` | Set up GroundTruth OS for your project |
| `gthos auth login` | Authenticate via browser |
| `gthos auth status` | Show current auth state |
| `gthos docs list` | List canonical documents |
| `gthos docs get <type>` | Read a canonical document |
| `gthos docs update <type>` | Update a canonical document |
| `gthos export prompt` | Compile canonical docs into a system prompt |
| `gthos changes` | See recent changes by others |
| `gthos decide <title>` | Record an architectural decision |
| `gthos workspace` | Show current workspace info |

## Environment Variables

| Variable | Description |
|----------|-------------|
| `GTHOS_API_KEY` | API key for authentication (alternative to `gthos auth login`) |
| `GTHOS_BASE_URL` | Server URL (default: `https://groundtruthos.ai`) |

## Links

- [GroundTruth OS](https://groundtruthos.ai)
- [Documentation](https://groundtruthos.ai/guide)
npm package: @gtile/adw-1
Description: GJS TypeScript type definitions for Adw-1, generated from library version 1.4.0
Author: ts-for-gir
Latest version: 1.4.0-3.2.3


# Adw-1

![version](https://img.shields.io/npm/v/@gtile/adw-1)
![downloads/week](https://img.shields.io/npm/dw/@gtile/adw-1)


GJS TypeScript type definitions for Adw-1, generated from library version 1.4.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

Building blocks for modern GNOME applications

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/adw-1
```

## Usage

You can import this package into your project like this:
```ts
import Adw from '@gtile/adw-1';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Adw = require('@gtile/adw-1');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/adw-1` or `@gtile/adw-1/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/adw-1'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/adw-1"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Adw from 'gi://Adw?version=1';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/adw-1` or `@gtile/adw-1/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/adw-1'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/adw-1"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Adw = imports.gi.Adw;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/atk-1.0
Description: GJS TypeScript type definitions for Atk-1.0, generated from library version 2.50.0
Author: ts-for-gir
Latest version: 2.50.0-3.2.3


# Atk-1.0

![version](https://img.shields.io/npm/v/@gtile/atk-1.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/atk-1.0)


GJS TypeScript type definitions for Atk-1.0, generated from library version 2.50.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

ATK provides the set of accessibility interfaces that are implemented by other toolkits and applications. Using the ATK interfaces, accessibility tools have full access to view and control running applications.

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/atk-1.0
```

## Usage

You can import this package into your project like this:
```ts
import Atk from '@gtile/atk-1.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Atk = require('@gtile/atk-1.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/atk-1.0` or `@gtile/atk-1.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/atk-1.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/atk-1.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Atk from 'gi://Atk?version=1.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/atk-1.0` or `@gtile/atk-1.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/atk-1.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/atk-1.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Atk = imports.gi.Atk;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/cally-13
Description: GJS TypeScript type definitions for Cally-13, generated from library version 13.0.0
Author: ts-for-gir
Latest version: 13.0.0-3.2.3


# Cally-13

![version](https://img.shields.io/npm/v/@gtile/cally-13)
![downloads/week](https://img.shields.io/npm/dw/@gtile/cally-13)


GJS TypeScript type definitions for Cally-13, generated from library version 13.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/cally-13
```

## Usage

You can import this package into your project like this:
```ts
import Cally from '@gtile/cally-13';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Cally = require('@gtile/cally-13');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/cally-13` or `@gtile/cally-13/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/cally-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/cally-13"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Cally from 'gi://Cally?version=13';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/cally-13` or `@gtile/cally-13/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/cally-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/cally-13"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Cally = imports.gi.Cally;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/clutter-13
Description: GJS TypeScript type definitions for Clutter-13, generated from library version 13.0.0
Author: ts-for-gir
Latest version: 13.0.0-3.2.3


# Clutter-13

![version](https://img.shields.io/npm/v/@gtile/clutter-13)
![downloads/week](https://img.shields.io/npm/dw/@gtile/clutter-13)


GJS TypeScript type definitions for Clutter-13, generated from library version 13.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/clutter-13
```

## Usage

You can import this package into your project like this:
```ts
import Clutter from '@gtile/clutter-13';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Clutter = require('@gtile/clutter-13');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/clutter-13` or `@gtile/clutter-13/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/clutter-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/clutter-13"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Clutter from 'gi://Clutter?version=13';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/clutter-13` or `@gtile/clutter-13/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/clutter-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/clutter-13"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Clutter = imports.gi.Clutter;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/cogl-13
Description: GJS TypeScript type definitions for Cogl-13, generated from library version 13.0.0
Author: ts-for-gir
Latest version: 13.0.0-3.2.3


# Cogl-13

![version](https://img.shields.io/npm/v/@gtile/cogl-13)
![downloads/week](https://img.shields.io/npm/dw/@gtile/cogl-13)


GJS TypeScript type definitions for Cogl-13, generated from library version 13.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/cogl-13
```

## Usage

You can import this package into your project like this:
```ts
import Cogl from '@gtile/cogl-13';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Cogl = require('@gtile/cogl-13');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/cogl-13` or `@gtile/cogl-13/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/cogl-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/cogl-13"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Cogl from 'gi://Cogl?version=13';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/cogl-13` or `@gtile/cogl-13/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/cogl-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/cogl-13"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Cogl = imports.gi.Cogl;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/coglpango-13
Description: GJS TypeScript type definitions for CoglPango-13, generated from library version 13.0.0
Author: ts-for-gir
Latest version: 13.0.0-3.2.3


# CoglPango-13

![version](https://img.shields.io/npm/v/@gtile/coglpango-13)
![downloads/week](https://img.shields.io/npm/dw/@gtile/coglpango-13)


GJS TypeScript type definitions for CoglPango-13, generated from library version 13.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/coglpango-13
```

## Usage

You can import this package into your project like this:
```ts
import CoglPango from '@gtile/coglpango-13';
```

Or if you prefer CommonJS, you can also use this:
```ts
const CoglPango = require('@gtile/coglpango-13');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/coglpango-13` or `@gtile/coglpango-13/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/coglpango-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/coglpango-13"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import CoglPango from 'gi://CoglPango?version=13';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/coglpango-13` or `@gtile/coglpango-13/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/coglpango-13'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/coglpango-13"],
  ...
}
```

Now you have also type support for this, too:

```ts
const CoglPango = imports.gi.CoglPango;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gck-2
Description: GJS TypeScript type definitions for Gck-2, generated from library version 4.1.0
Author: ts-for-gir
Latest version: 4.1.0-3.2.3


# Gck-2

![version](https://img.shields.io/npm/v/@gtile/gck-2)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gck-2)


GJS TypeScript type definitions for Gck-2, generated from library version 4.1.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

GLib wrapper library for PKCS#11

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gck-2
```

## Usage

You can import this package into your project like this:
```ts
import Gck from '@gtile/gck-2';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Gck = require('@gtile/gck-2');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gck-2` or `@gtile/gck-2/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gck-2'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gck-2"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Gck from 'gi://Gck?version=2';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gck-2` or `@gtile/gck-2/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gck-2'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gck-2"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Gck = imports.gi.Gck;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gcr-4
Description: GJS TypeScript type definitions for Gcr-4, generated from library version 4.1.0
Author: ts-for-gir
Latest version: 4.1.0-3.2.3


# Gcr-4

![version](https://img.shields.io/npm/v/@gtile/gcr-4)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gcr-4)


GJS TypeScript type definitions for Gcr-4, generated from library version 4.1.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

A library for bits of crypto UI and parsing

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gcr-4
```

## Usage

You can import this package into your project like this:
```ts
import Gcr from '@gtile/gcr-4';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Gcr = require('@gtile/gcr-4');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gcr-4` or `@gtile/gcr-4/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gcr-4'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gcr-4"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Gcr from 'gi://Gcr?version=4';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gcr-4` or `@gtile/gcr-4/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gcr-4'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gcr-4"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Gcr = imports.gi.Gcr;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gdk-4.0
Description: GJS TypeScript type definitions for Gdk-4.0, generated from library version 4.0.0
Author: ts-for-gir
Latest version: 4.0.0-3.2.3


# Gdk-4.0

![version](https://img.shields.io/npm/v/@gtile/gdk-4.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gdk-4.0)


GJS TypeScript type definitions for Gdk-4.0, generated from library version 4.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gdk-4.0
```

## Usage

You can import this package into your project like this:
```ts
import Gdk from '@gtile/gdk-4.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Gdk = require('@gtile/gdk-4.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gdk-4.0` or `@gtile/gdk-4.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gdk-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gdk-4.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Gdk from 'gi://Gdk?version=4.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gdk-4.0` or `@gtile/gdk-4.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gdk-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gdk-4.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Gdk = imports.gi.Gdk;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gdkpixbuf-2.0
Description: GJS TypeScript type definitions for GdkPixbuf-2.0, generated from library version 2.0.0
Author: ts-for-gir
Latest version: 2.0.0-3.2.3


# GdkPixbuf-2.0

![version](https://img.shields.io/npm/v/@gtile/gdkpixbuf-2.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gdkpixbuf-2.0)


GJS TypeScript type definitions for GdkPixbuf-2.0, generated from library version 2.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

GdkPixbuf is a library for image loading and manipulation. The GdkPixbuf documentation contains both the programmer's guide and the API reference.

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gdkpixbuf-2.0
```

## Usage

You can import this package into your project like this:
```ts
import GdkPixbuf from '@gtile/gdkpixbuf-2.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const GdkPixbuf = require('@gtile/gdkpixbuf-2.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gdkpixbuf-2.0` or `@gtile/gdkpixbuf-2.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gdkpixbuf-2.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gdkpixbuf-2.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gdkpixbuf-2.0` or `@gtile/gdkpixbuf-2.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gdkpixbuf-2.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gdkpixbuf-2.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const GdkPixbuf = imports.gi.GdkPixbuf;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gl-1.0
Description: GJS TypeScript type definitions for GL-1.0, generated from library version 1.0.0
Author: ts-for-gir
Latest version: 1.0.0-3.2.3


# GL-1.0

![version](https://img.shields.io/npm/v/@gtile/gl-1.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gl-1.0)


GJS TypeScript type definitions for GL-1.0, generated from library version 1.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gl-1.0
```

## Usage

You can import this package into your project like this:
```ts
import GL from '@gtile/gl-1.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const GL = require('@gtile/gl-1.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gl-1.0` or `@gtile/gl-1.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gl-1.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gl-1.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import GL from 'gi://GL?version=1.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gl-1.0` or `@gtile/gl-1.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gl-1.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gl-1.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const GL = imports.gi.GL;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/glib-2.0
Description: GJS TypeScript type definitions for GLib-2.0, generated from library version 2.78.0
Author: ts-for-gir
Latest version: 2.78.0-3.2.3


# GLib-2.0

![version](https://img.shields.io/npm/v/@gtile/glib-2.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/glib-2.0)


GJS TypeScript type definitions for GLib-2.0, generated from library version 2.78.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

GLib provides the core application building blocks for libraries and applications written in C. It provides the core object system used in GNOME, the main loop implementation, and a large set of utility functions for strings and common data structures.

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/glib-2.0
```

## Usage

You can import this package into your project like this:
```ts
import GLib from '@gtile/glib-2.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const GLib = require('@gtile/glib-2.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/glib-2.0` or `@gtile/glib-2.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/glib-2.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/glib-2.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import GLib from 'gi://GLib?version=2.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/glib-2.0` or `@gtile/glib-2.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/glib-2.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/glib-2.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const GLib = imports.gi.GLib;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gnome-shell
Description: GJS TypeScript type definitions for GNOME Shell Extensions
Author: Pascal Garber
Latest version: 3.0.0


# GNOME Shell TypeScript Type Definitions

GJS TypeScript type definitions for GNOME Shell Extensions.

The types are currently in a very experimental state and rely on your contributions. Therefore, this project can be seen as a basic structure for further development. The typescript types of the `.gir` files [are generated](https://www.npmjs.com/package/@girs/gjs) with [ts-for-gir](https://github.com/gjsify/ts-for-gir), the rest is written by hand and contained in this repository.

## Install

To use this type definitions, install them with NPM like this:

```bash
npm install @girs/gnome-shell
```

## Usage

You can import this package into your project like this:

```ts
import GnomeShell from '@girs/gnome-shell';
```

If you prefer CommonJS, you can also use this:

```ts
const GnomeShell = require('@girs/gnome-shell');
```

GNOME Shell extensions currently [do not yet support ESM imports](https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1499) and instead rely on the global `imports` [variable from GJS](https://gjs.guide/guides/gjs/intro.html). However, you can still use ESM syntax in TypeScript, but you need to ensure that your bundler translates these imports to CommonJS. We recommended to use [esbuild](https://esbuild.github.io/), which we also use [in our example](examples/hello-world).
npm package: @gtile/gnomebg-4.0
Description: GJS TypeScript type definitions for GnomeBG-4.0, generated from library version 4.0.0
Author: ts-for-gir
Latest version: 4.0.0-3.2.3


# GnomeBG-4.0

![version](https://img.shields.io/npm/v/@gtile/gnomebg-4.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gnomebg-4.0)


GJS TypeScript type definitions for GnomeBG-4.0, generated from library version 4.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gnomebg-4.0
```

## Usage

You can import this package into your project like this:
```ts
import GnomeBG from '@gtile/gnomebg-4.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const GnomeBG = require('@gtile/gnomebg-4.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gnomebg-4.0` or `@gtile/gnomebg-4.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gnomebg-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gnomebg-4.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import GnomeBG from 'gi://GnomeBG?version=4.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gnomebg-4.0` or `@gtile/gnomebg-4.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gnomebg-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gnomebg-4.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const GnomeBG = imports.gi.GnomeBG;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gnomedesktop-4.0
Description: GJS TypeScript type definitions for GnomeDesktop-4.0, generated from library version 4.0.0
Author: ts-for-gir
Latest version: 4.0.0-3.2.3


# GnomeDesktop-4.0

![version](https://img.shields.io/npm/v/@gtile/gnomedesktop-4.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gnomedesktop-4.0)


GJS TypeScript type definitions for GnomeDesktop-4.0, generated from library version 4.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gnomedesktop-4.0
```

## Usage

You can import this package into your project like this:
```ts
import GnomeDesktop from '@gtile/gnomedesktop-4.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const GnomeDesktop = require('@gtile/gnomedesktop-4.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gnomedesktop-4.0` or `@gtile/gnomedesktop-4.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gnomedesktop-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gnomedesktop-4.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import GnomeDesktop from 'gi://GnomeDesktop?version=4.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gnomedesktop-4.0` or `@gtile/gnomedesktop-4.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gnomedesktop-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gnomedesktop-4.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const GnomeDesktop = imports.gi.GnomeDesktop;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gobject-2.0
Description: GJS TypeScript type definitions for GObject-2.0, generated from library version 2.78.0
Author: ts-for-gir
Latest version: 2.78.0-3.2.3


# GObject-2.0

![version](https://img.shields.io/npm/v/@gtile/gobject-2.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gobject-2.0)


GJS TypeScript type definitions for GObject-2.0, generated from library version 2.78.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

GObject provides the object system used for Pango and GTK+.

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gobject-2.0
```

## Usage

You can import this package into your project like this:
```ts
import GObject from '@gtile/gobject-2.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const GObject = require('@gtile/gobject-2.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gobject-2.0` or `@gtile/gobject-2.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gobject-2.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gobject-2.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import GObject from 'gi://GObject?version=2.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gobject-2.0` or `@gtile/gobject-2.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gobject-2.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gobject-2.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const GObject = imports.gi.GObject;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/graphene-1.0
Description: GJS TypeScript type definitions for Graphene-1.0, generated from library version 1.0.0
Author: ts-for-gir
Latest version: 1.0.0-3.2.3


# Graphene-1.0

![version](https://img.shields.io/npm/v/@gtile/graphene-1.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/graphene-1.0)


GJS TypeScript type definitions for Graphene-1.0, generated from library version 1.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.

A thin layer of types for graphic libraries

## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/graphene-1.0
```

## Usage

You can import this package into your project like this:
```ts
import Graphene from '@gtile/graphene-1.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Graphene = require('@gtile/graphene-1.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/graphene-1.0` or `@gtile/graphene-1.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/graphene-1.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/graphene-1.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Graphene from 'gi://Graphene?version=1.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/graphene-1.0` or `@gtile/graphene-1.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/graphene-1.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/graphene-1.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Graphene = imports.gi.Graphene;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gsk-4.0
Description: GJS TypeScript type definitions for Gsk-4.0, generated from library version 4.0.0
Author: ts-for-gir
Latest version: 4.0.0-3.2.3


# Gsk-4.0

![version](https://img.shields.io/npm/v/@gtile/gsk-4.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gsk-4.0)


GJS TypeScript type definitions for Gsk-4.0, generated from library version 4.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gsk-4.0
```

## Usage

You can import this package into your project like this:
```ts
import Gsk from '@gtile/gsk-4.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Gsk = require('@gtile/gsk-4.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gsk-4.0` or `@gtile/gsk-4.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gsk-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gsk-4.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Gsk from 'gi://Gsk?version=4.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gsk-4.0` or `@gtile/gsk-4.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gsk-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gsk-4.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Gsk = imports.gi.Gsk;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
npm package: @gtile/gtk-4.0
Description: GJS TypeScript type definitions for Gtk-4.0, generated from library version 4.12.3
Author: ts-for-gir
Latest version: 4.12.3-3.2.3


# Gtk-4.0

![version](https://img.shields.io/npm/v/@gtile/gtk-4.0)
![downloads/week](https://img.shields.io/npm/dw/@gtile/gtk-4.0)


GJS TypeScript type definitions for Gtk-4.0, generated from library version 4.12.3 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.2.3.


## Install

To use this type definitions, install them with NPM:
```bash
npm install @gtile/gtk-4.0
```

## Usage

You can import this package into your project like this:
```ts
import Gtk from '@gtile/gtk-4.0';
```

Or if you prefer CommonJS, you can also use this:
```ts
const Gtk = require('@gtile/gtk-4.0');
```

### Ambient Modules

You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
For this you need to include `@gtile/gtk-4.0` or `@gtile/gtk-4.0/ambient` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gtk-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gtk-4.0"],
  ...
}
```

Now you can import the ambient module with TypeScript support: 

```ts
import Gtk from 'gi://Gtk?version=4.0';
```

### Global import

You can also import the module with Typescript support using the global `imports.gi` object of GJS.
For this you need to include `@gtile/gtk-4.0` or `@gtile/gtk-4.0/import` in your `tsconfig` or entry point Typescript file:

`index.ts`:
```ts
import '@gtile/gtk-4.0'
```

`tsconfig.json`:
```json
{
  "compilerOptions": {
    ...
  },
  "include": ["@gtile/gtk-4.0"],
  ...
}
```

Now you have also type support for this, too:

```ts
const Gtk = imports.gi.Gtk;
```

### Bundle

Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).

## Other packages

All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).