# Canvacard

### Classes

[Canvacard](#Canvacard)

### Functions

[trigger(image)](#trigger) ⇒ `Promise.<Buffer>`

Trigger an image

[invert(image)](#invert) ⇒ `Promise.<Buffer>`

Invert an image

[sepia(image)](#sepia) ⇒ `Promise.<Buffer>`

Sepia an image

[greyscale(image)](#greyscale) ⇒ `Promise.<Buffer>`

Greyscale an image

[brightness(image, amount)](#brightness) ⇒ `Promise.<Buffer>`

Edit the brightness of the image

[darkness(image, amount)](#darkness) ⇒ `Promise.<Buffer>`

Darken an image

[threshold(image, amount)](#threshold) ⇒ `Promise.<Buffer>`[convolute(image, matrix, opaque)](#convolute) ⇒ `Promise.<Buffer>`

Convolute an image

[pixelate(image, pixels)](#pixelate) ⇒ `Promise.<Buffer>`

Pixelate an image

[sharpen(image, lvl)](#sharpen) ⇒ `Promise.<Buffer>`

Sharpen an image

[burn(image, lvl)](#burn) ⇒ `Promise.<Buffer>`

Burn an image

[circle(image)](#circle) ⇒ `Promise.<Buffer>`

Circle an image

[fuse(image1, image2)](#fuse) ⇒ `Promise.<Buffer>`

Fuse two images

[resize(image, width, height)](#resize) ⇒ `Promise.<Buffer>`

Resize an image

[kiss(image1, image2)](#kiss) ⇒ `Promise.<Buffer>`

Kiss someone ( ͡° ͜ʖ ͡°)

[spank(image1, image2)](#spank) ⇒ `Promise.<Buffer>`

To spank someone ( ͡° ͜ʖ ͡°)

[slap(image1, image2)](#slap) ⇒ `Promise.<Buffer>`

Slap someone ( ͡° ͜ʖ ͡°)

[facepalm(image)](#facepalm) ⇒ `Promise.<Buffer>`

Facepalm someone

[colorfy(image, color)](#colorfy) ⇒ `Promise.<Buffer>`

Colorfy an image

[distracted(image1, image2, image3)](#distracted) ⇒ `Promise.<Buffer>`

Distract someone

[jail(image, greyscale)](#jail) ⇒ `Promise.<Buffer>`

Create a jail image

[bed(image1, image2)](#bed) ⇒ `Promise.<Buffer>`

Create a bed image

[delete(image, dark)](#delete) ⇒ `Promise.<Buffer>`

Create a deleted image

[gradient(colorFrom, colorTo, width, height)](#gradient) ⇒ `Promise.<Buffer>`

Create a gradient image

[quote(options, \[font\])](#quote) ⇒ `Promise.<Buffer>`

Create a fake quote image

[phub(options, \[font\])](#phub) ⇒ `Promise.<Buffer>`

PornHub Comment

[wanted(image)](#wanted) ⇒ `Promise.<Buffer>`

Create a "wanted" image

[wasted(image)](#wasted) ⇒ `Promise.<Buffer>`

Create a "wasted" image

[youtube(ops)](#youtube) ⇒ `Promise.<Buffer>`

Create a YouTube comment image

[write(data, name)](#write) ⇒ `void`

Writes data as a file

[reply(options)](#reply) ⇒ `Promise.<Buffer>`

Discord Reply Clone

### Canvacard

**Kind**: global class<br>

#### new Canvacard()

Image generator

**Example**

```js
const canvacard = require("canvacard");
canvacard.Canvas.trigger("./image.png")
  .then(triggered => {
    canvacard.write(triggered, "triggered.gif");
  })
  .catch(console.error);
```

### trigger(image) ⇒ `Promise.<Buffer>`

Trigger an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Triggered image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description      |
| ----- | -------------------- | ---------------- |
| image | `string` \| `Buffer` | Image to trigger |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.trigger("./image.png")
    .then(triggered => {
      canvacard.write(triggered, "triggered.gif");
    })
    .catch(console.error);
```

### invert(image) ⇒ `Promise.<Buffer>`

Invert an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Inverted image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description     |
| ----- | -------------------- | --------------- |
| image | `string` \| `Buffer` | Image to invert |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.invert("./image.png")
    .then(inverted => {
      canvacard.write(inverted, "inverted.png");
    })
    .catch(console.error);
```

### sepia(image) ⇒ `Promise.<Buffer>`

Sepia an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Sepia image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description    |
| ----- | -------------------- | -------------- |
| image | `string` \| `Buffer` | Image to sepia |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.sepia("./image.png")
    .then(sepia => {
      canvacard.write(sepia, "sepia.png");
    })
    .catch(console.error);
```

### greyscale(image) ⇒ `Promise.<Buffer>`

Greyscale an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Greyscale image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description        |
| ----- | -------------------- | ------------------ |
| image | `string` \| `Buffer` | Image to greyscale |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.greyscale("./image.png")
    .then(greyscale => {
      canvacard.write(greyscale, "greyscale.png");
    })
    .catch(console.error);
```

### brightness(image, amount) ⇒ `Promise.<Buffer>`

Edit the brightness of the image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Brightened image\
**Throws**:

* `APIError` If image is not provided o la cantidad no es un número

| Param  | Type                 | Description          |
| ------ | -------------------- | -------------------- |
| image  | `string` \| `Buffer` | Image to brighten    |
| amount | `number`             | Amount of brightness |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.brightness("./image.png", 50)
    .then(brightened => {
      canvacard.write(brightened, "brightened.png");
    })
    .catch(console.error);
```

### darkness(image, amount) ⇒ `Promise.<Buffer>`

Darken an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Darkened image\
**Throws**:

* `APIError` If image is not provided o la cantidad no es un número

| Param  | Type                 | Description        |
| ------ | -------------------- | ------------------ |
| image  | `string` \| `Buffer` | Image to darken    |
| amount | `number`             | Amount of darkness |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.darkness("./image.png", 50)
    .then(darkened => {
      canvacard.write(darkened, "darkened.png");
    })
    .catch(console.error);
```

### threshold(image, amount) ⇒ `Promise.<Buffer>`

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Thresholded image\
**Throws**:

* `APIError` If image is not provided o la cantidad no es un número

**Descrioption**: Threshold an image

| Param  | Type                 | Description         |
| ------ | -------------------- | ------------------- |
| image  | `string` \| `Buffer` | Image to threshold  |
| amount | `number`             | Amount of threshold |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.threshold("./image.png", 128)
    .then(thresholded => {
      canvacard.write(thresholded, "thresholded.png");
    })
    .catch(console.error);
```

### convolute(image, matrix, opaque) ⇒ `Promise.<Buffer>`

Convolute an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Convoluted image\
**Throws**:

* `APIError` If image is not provided o la matriz no es un Array

| Param  | Type                 | Description                   |
| ------ | -------------------- | ----------------------------- |
| image  | `string` \| `Buffer` | Image to convolute            |
| matrix | `Array.<number>`     | Convolution matrix            |
| opaque | `boolean`            | If the image should be opaque |

**Example**

```js
    const canvacard = require("canvacard");
    const matrix = [0, -1, 0, -1, 5, -1, 0, -1, 0];  // Ejemplo de matriz de convolución
    canvacard.Canvas.convolute("./image.png", matrix, true)
    .then(convoluted => {
      canvacard.write(convoluted, "convoluted.png");
    })
    .catch(console.error);
```

### pixelate(image, pixels) ⇒ `Promise.<Buffer>`

Pixelate an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Pixelated image\
**Throws**:

* `APIError` If image is not provided o los píxeles no son un número

| Param  | Type                 | Description       |
| ------ | -------------------- | ----------------- |
| image  | `string` \| `Buffer` | Image to pixelate |
| pixels | `number`             | Amount of pixels  |

**Example**

````js
    const canvacard = require("canvacard");
    canvacard.Canvas.pixelate("./image.png", 5)
    .then(pixelated => {
      canvacard.write(pixelated, "pixelated.png");
    })
    .catch(console.error);
<a name="sharpen"></a>

## sharpen(image, lvl) ⇒ <code>Promise.&lt;Buffer&gt;</code>
Sharpen an image

**Kind**: global function  
**Returns**: <code>Promise.&lt;Buffer&gt;</code> - Sharpened image  
**Throws**:

- <code>APIError</code> If image is not provided o el nivel no es un número


| Param | Type | Description |
| --- | --- | --- |
| image | <code>string</code> \| <code>Buffer</code> | Image to sharpen |
| lvl | <code>number</code> | Level of sharpening |

**Example**  
```js
    const canvacard = require("canvacard");
    canvacard.Canvas.sharpen("./image.png", 1)
    .then(sharpened => {
      canvacard.write(sharpened, "sharpened.png");
    })
    .catch(console.error);
````

### burn(image, lvl) ⇒ `Promise.<Buffer>`

Burn an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Burned image\
**Throws**:

* `APIError` If image is not provided o el nivel no es un número

| Param | Type                 | Description      |
| ----- | -------------------- | ---------------- |
| image | `string` \| `Buffer` | Image to burn    |
| lvl   | `number`             | Level of burning |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.burn("./image.png", 1)
    .then(burned => {
      canvacard.write(burned, "burned.png");
    })
    .catch(console.error);
```

### circle(image) ⇒ `Promise.<Buffer>`

Circle an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Circled image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description     |
| ----- | -------------------- | --------------- |
| image | `string` \| `Buffer` | Image to circle |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.circle("./image.png")
    .then(circled => {
      canvacard.write(circled, "circled.png");
    })
    .catch(console.error);
```

### fuse(image1, image2) ⇒ `Promise.<Buffer>`

Fuse two images

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Fused image\
**Throws**:

* `APIError` If image is not provided

| Param  | Type                 | Description  |
| ------ | -------------------- | ------------ |
| image1 | `string` \| `Buffer` | First image  |
| image2 | `string` \| `Buffer` | Second image |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.fuse("./image1.png", "./image2.png")
      .then(fused => {
      canvacard.write(fused, "fused.png");
    })
    .catch(console.error);
```

### resize(image, width, height) ⇒ `Promise.<Buffer>`

Resize an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Resized image\
**Throws**:

* `APIError` If image is not provided

| Param  | Type                 | Description     |
| ------ | -------------------- | --------------- |
| image  | `string` \| `Buffer` | Image to resize |
| width  | `number`             | Width           |
| height | `number`             | Height          |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.resize("./image.png", 500, 500)
    .then(resized => {
      canvacard.write(resized, "resized.png");
    })
    .catch(console.error);
```

### kiss(image1, image2) ⇒ `Promise.<Buffer>`

Kiss someone ( ͡° ͜ʖ ͡°)

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Imagen de beso\
**Throws**:

* `APIError` If image is not provided

| Param  | Type                 | Description  |
| ------ | -------------------- | ------------ |
| image1 | `string` \| `Buffer` | First image  |
| image2 | `string` \| `Buffer` | Second image |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.kiss("./image1.png", "./image2.png")
    .then(kissed => {
      canvacard.write(kissed, "kissed.png");
    })
    .catch(console.error);
```

### spank(image1, image2) ⇒ `Promise.<Buffer>`

To spank someone ( ͡° ͜ʖ ͡°)

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Image of spank\
**Throws**:

* `APIError` If image is not provided

| Param  | Type                 | Description  |
| ------ | -------------------- | ------------ |
| image1 | `string` \| `Buffer` | First image  |
| image2 | `string` \| `Buffer` | Second image |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.spank("./image1.png", "./image2.png")
    .then(spanked => {
      canvacard.write(spanked, "spanked.png");
    })
    .catch(console.error);
```

### slap(image1, image2) ⇒ `Promise.<Buffer>`

Slap someone ( ͡° ͜ʖ ͡°)

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Image of slap\
**Throws**:

* `APIError` If image is not provided

| Param  | Type                 | Description  |
| ------ | -------------------- | ------------ |
| image1 | `string` \| `Buffer` | First image  |
| image2 | `string` \| `Buffer` | Second image |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.slap("./image1.png", "./image2.png")
    .then(slap => {
      canvacard.write(slap, "slap.png");
    })
    .catch(console.error);
```

### facepalm(image) ⇒ `Promise.<Buffer>`

Facepalm someone

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Image of facepalm\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description       |
| ----- | -------------------- | ----------------- |
| image | `string` \| `Buffer` | Image to facepalm |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.facepalm("./image.png")
    .then(facepalm => {
      canvacard.write(facepalm, "facepalm.png");
    })
    .catch(console.error);
```

### colorfy(image, color) ⇒ `Promise.<Buffer>`

Colorfy an image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Colorfied image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description                       |
| ----- | -------------------- | --------------------------------- |
| image | `string` \| `Buffer` | Image to colorfy                  |
| color | `string`             | Color to apply to the image (hex) |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.colorfy("./image.png", "#FF0000")
    .then(colorfy => {
      canvacard.write(colorfy, "colorfy.png");
    })
    .catch(console.error);
```

### distracted(image1, image2, image3) ⇒ `Promise.<Buffer>`

Distract someone

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Distracted image\
**Throws**:

* `APIError` If image is not provided

| Param  | Type                 | Description                         |
| ------ | -------------------- | ----------------------------------- |
| image1 | `string` \| `Buffer` | Face for the girl in red.           |
| image2 | `string` \| `Buffer` | Face for the boy.                   |
| image3 | `string` \| `Buffer` | Face for the other girl \[optional] |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.distracted("./image1.png", "./image2.png", "./image3.png")
    .then(distracted => {
      canvacard.write(distracted, "distracted.png");
    })
    .catch(console.error);
```

### jail(image, greyscale) ⇒ `Promise.<Buffer>`

Create a jail image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Jailed image\
**Throws**:

* `APIError` If image is not provided

| Param     | Type                 | Description                      |
| --------- | -------------------- | -------------------------------- |
| image     | `string` \| `Buffer` | Image to jail                    |
| greyscale | `boolean`            | If the image should be greyscale |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.jail("./image.png")
    .then(jail => {
      canvacard.write(jail, "jail.png");
    })
    .catch(console.error);
```

### bed(image1, image2) ⇒ `Promise.<Buffer>`

Create a bed image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Imagen de cama\
**Throws**:

* `APIError` If image is not provided

| Param  | Type                 | Description  |
| ------ | -------------------- | ------------ |
| image1 | `string` \| `Buffer` | First image  |
| image2 | `string` \| `Buffer` | Second image |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.bed("./image1.png", "./image2.png")
    .then(bed => {
      canvacard.write(bed, "bed.png");
    })
    .catch(console.error);
```

### delete(image, dark) ⇒ `Promise.<Buffer>`

Create a deleted image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Deleted image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description                 |
| ----- | -------------------- | --------------------------- |
| image | `string` \| `Buffer` | Image to delete             |
| dark  | `boolean`            | If the image should be dark |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.delete("./image.png")
    .then(deleted => {
      canvacard.write(deleted, "deleted.png");
    })
    .catch(console.error);
```

### gradient(colorFrom, colorTo, width, height) ⇒ `Promise.<Buffer>`

Create a gradient image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Gradient image\
**Throws**:

* `APIError` If colorFrom or colorTo is not provided

| Param     | Type     | Description     |
| --------- | -------- | --------------- |
| colorFrom | `string` | First color     |
| colorTo   | `string` | Second color    |
| width     | `number` | Width of image  |
| height    | `number` | Height of image |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.gradient("#FF0000", "#0000FF", 500, 500)
    .then(gradient => {
      canvacard.write(gradient, "gradient.png");
    })
    .catch(console.error);
```

### quote(options, \[font]) ⇒ `Promise.<Buffer>`

Create a fake quote image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Quote image

| Param               | Type                 | Default               | Description            |
| ------------------- | -------------------- | --------------------- | ---------------------- |
| options             | `object`             |                       | Options                |
| \[options.image]    | `Buffer` \| `string` |                       | Image                  |
| \[options.message]  | `string`             |                       | Message                |
| \[options.username] | `string`             |                       | Username               |
| \[options.color]    | `string`             |                       | Color                  |
| \[font]             | `string`             | `"&quot;Arial&quot;"` | Text font for the card |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.quote({ image: "./image.png", message: "This is amazing!", username: "Clyde", color: "#FFFFFF" })
    .then(quote => {
      canvacard.write(quote, "quote.png");
    })
    .catch(console.error);
```

### phub(options, \[font]) ⇒ `Promise.<Buffer>`

PornHub Comment

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - PornHub Comment image\
**Throws**:

* `APIError` If username, message or image is not provided

| Param               | Type                 | Default               | Description        |
| ------------------- | -------------------- | --------------------- | ------------------ |
| options             | `Object`             |                       | Options            |
| \[options.username] | `String`             |                       | Username           |
| \[options.message]  | `String`             |                       | Message            |
| \[options.image]    | `String` \| `Buffer` |                       | Image              |
| \[font]             | `string`             | `"&quot;Arial&quot;"` | Text font for card |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.phub({ username: "Clyde", message: "This is amazing!", image: "./image.png" })
    .then(phub => {
      canvacard.write(phub, "phub.png");
    })
    .catch(console.error);
```

### wanted(image) ⇒ `Promise.<Buffer>`

Create a "wanted" image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Wanted image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description     |
| ----- | -------------------- | --------------- |
| image | `string` \| `Buffer` | Image to wanted |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.wanted("./image.png")
    .then(wanted => {
      canvacard.write(wanted, "wanted.png");
    })
    .catch(console.error);
```

### wasted(image) ⇒ `Promise.<Buffer>`

Create a "wasted" image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Wasted image\
**Throws**:

* `APIError` If image is not provided

| Param | Type                 | Description     |
| ----- | -------------------- | --------------- |
| image | `string` \| `Buffer` | Image to wasted |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.wasted("./image.png")
    .then(wasted => {
      canvacard.write(wasted, "wasted.png");
    })
    .catch(console.error);
```

### youtube(ops) ⇒ `Promise.<Buffer>`

Create a YouTube comment image

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - YouTube comment image\
**Throws**:

* `APIError` If username, content or avatar is not provided

| Param           | Type                 | Default | Description |
| --------------- | -------------------- | ------- | ----------- |
| ops             | `object`             |         | Options     |
| \[ops.username] | `string`             |         | Username    |
| \[ops.content]  | `string`             |         | Content     |
| \[ops.avatar]   | `string` \| `Buffer` |         | Avatar      |
| \[ops.dark]     | `boolean`            | `false` | Dark mode   |

**Example**

```js
    const canvacard = require("canvacard");
    canvacard.Canvas.youtube({ username: "Clyde", content: "This is amazing!", avatar: "./image.png" })
    .then(youtube => {
      canvacard.write(youtube, "youtube.png");
    })
    .catch(console.error);
```

### write(data, name) ⇒ `void`

Writes data as a file

**Kind**: global function

| Param | Type     | Description   |
| ----- | -------- | ------------- |
| data  | `Buffer` | data to write |
| name  | `string` | file name     |

### reply(options) ⇒ `Promise.<Buffer>`

Discord Reply Clone

**Kind**: global function\
**Returns**: `Promise.<Buffer>` - Reply image\
**Throws**:

* `APIError` If the avatar, username or message is not provided

| Param                | Type                 | Description                                   |
| -------------------- | -------------------- | --------------------------------------------- |
| options              | `object`             | Options                                       |
| \[options.avatar1]   | `string` \| `Buffer` | Avatar of the person who responded            |
| \[options.avatar2]   | `string` \| `Buffer` | Avatar of the other person                    |
| \[options.user1]     | `string`             | Username of the person who responded          |
| \[options.user2]     | `string`             | Username of the other person                  |
| \[options.hex1]      | `string`             | Hexadecimal color of the person who responded |
| \[options.hex2]      | `string`             | Hexadecimal color of the other person         |
| \[options.mainText]  | `string`             | Message of the person who responded           |
| \[options.replyText] | `string`             | Message of the other person                   |

**Example**

```js
const img = "https://cdn.discordapp.com/embed/avatars/0.png";
  const img2 = "https://cdn.discordapp.com/embed/avatars/4.png";
  canvacard.Canvas.reply({
    avatar1: img,
    avatar2: img2,
    user1: "Maximus",
    user2: "SrGobi",
    hex1: "#FF3300",
    hex2: "#7289da",
    mainText: "kok",
    replyText: "Pog"
   })
  .then(img => canvacard.write(img, "reply.png"));
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://canvacard.srgobi.com/classes/canvacard.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.