@shad0wz7/nestjs-pdf 2.4.2 → 2.5.0

package/dist/index.d.cts

@@ -0,0 +1,530 @@
+import { DynamicModule, InjectionToken, ModuleMetadata, OnModuleDestroy, OnModuleInit, OptionalFactoryDependency } from "@nestjs/common";
+import { HandlebarsOptions } from "@gboutte/nestjs-hbs/dist/handlebars-options.interface";
+import { Browser } from "@puppeteer/browsers";
+import { Browser as Browser$1, BrowserContext, PDFOptions } from "puppeteer";
+import { LocalsObject, Options } from "pug";
+import { Data, Options as Options$1 } from "ejs";
+import { ConfigureOptions } from "nunjucks";
+import { EtaConfig } from "eta";
+import { EscapeFunction } from "mustache";
+import { HandlebarsService } from "@gboutte/nestjs-hbs";
+//#region src/puppeteer/browser/browser.service.d.ts
+declare enum BrowserTag {
+  LATEST = "latest",
+  BETA = "beta",
+  DEV = "dev",
+  STABLE = "stable",
+  CANARY = "canary"
+}
+type Headless = boolean | 'shell' | undefined;
+declare class BrowserService implements OnModuleDestroy {
+  private readonly cacheDir;
+  private readonly options?;
+  private _browserInstance;
+  private browser;
+  activeJobs: number;
+  totalJobs: number;
+  private recycleRequested;
+  private recycling;
+  private browserTag;
+  private useLockedBrowser;
+  private buildId;
+  constructor(pdfParams: PuppeteerParameters);
+  onModuleDestroy(): Promise<void>;
+  getBrowserInstance(args: string[], headless: boolean | 'shell' | undefined, executablePathBin: string | undefined): Promise<Browser$1>;
+  createContext(args: string[], headless: Headless, executablePath?: string): Promise<BrowserContext>;
+  markJobStarted(): void;
+  markJobFinished(): Promise<void>;
+  recycleBrowserIfNeeded(): Promise<void>;
+  private cleanupCacheBestEffort;
+  install(lock?: boolean): Promise<import("@puppeteer/browsers", { with: { "resolution-mode": "import" } }).InstalledBrowser | null | undefined>;
+  private registerCleanupHooks;
+  private loadBrowser;
+  setBrowser(browser: Browser): void;
+  getBrowser(): Browser;
+  private loadBrowserTag;
+  private loadBuildId;
+  setBrowserTag(browserTag: BrowserTag): void;
+  getBrowserTag(): BrowserTag;
+  getBuildId(): string | undefined;
+  setBuildId(value: string | undefined): void;
+  private loadUseLockedBrowser;
+  hasBrowserInstalled(browser: Browser, buildId: string): Promise<boolean>;
+  getExecutablePath(): Promise<string>;
+  private launchBrowser;
+  private writeLockFile;
+  getLockedBuildId(browser: Browser): string | null;
+}
+//#endregion
+//#region node_modules/.pnpm/@types+mjml-core@5.1.0/node_modules/@types/mjml-core/index.d.ts
+/**
+ * Options passed as an object to the mjml2html function
+ *
+ * https://documentation.mjml.io/#inside-node-js
+ */
+interface MJMLParsingOptions {
+  /**
+   * Default fonts imported in the HTML rendered by HTML
+   * ie. { 'Open Sans': 'https://fonts.googleapis.com/css?family=Open+Sans:300,400,500,700' }
+   *
+   * default: @see https://github.com/mjmlio/mjml/blob/master/packages/mjml-core/src/index.js
+   */
+  fonts?: {
+    [key: string]: string;
+  } | undefined;
+  /**
+   * Option to keep comments in the HTML output
+   * default: true
+   */
+  keepComments?: boolean | undefined;
+  /**
+   * Beautify the HTML output using prettier (parser: 'html', printWidth: 240).
+   * Mutually exclusive with minify — if minify is true, beautify is skipped.
+   * Note: the CLI defaults this to true; the programmatic API defaults to false.
+   * default: false
+   */
+  beautify?: boolean | undefined;
+  /**
+   * Minify the HTML output using htmlnano (with cssnano-preset-lite for CSS).
+   * Takes priority over beautify when both are true.
+   * default: false
+   */
+  minify?: boolean | undefined;
+  /**
+   * Options passed to htmlnano when minify is true.
+   * The minifyCss field accepts false, true, 'lite', or a cssnano options object.
+   * All htmlnano v3 options are accepted.
+   */
+  minifyOptions?: MJMLMinifyOptions | undefined;
+  /**
+   * How to validate your MJML
+   *
+   * skip: your document is rendered without going through validation
+   * soft: your document is going through validation and is rendered, even if it has errors
+   * strict: your document is going through validation and is not rendered if it has any error
+   *
+   * default: soft
+   */
+  validationLevel?: "strict" | "soft" | "skip" | undefined;
+  /**
+   * Full path of the specified file to use when resolving paths from mj-include components
+   * default: '.'
+   */
+  filePath?: string | undefined;
+  /**
+   * Directory (or directories) outside the template's own folder from which mj-include
+   * partials may be loaded. Added in mjml 5.1 as part of the include path-traversal hardening;
+   * includes resolving outside these allowed roots are denied.
+   */
+  includePath?: string | string[] | undefined;
+  /**
+   * The path or directory of the .mjmlconfig file
+   * default: process.cwd()
+   */
+  mjmlConfigPath?: string | undefined;
+  /**
+   * Use the config attribute defined in the .mjmlconfig file.
+   * The config passed into mjml2html overrides the .mjmlconfig.
+   * default: false
+   */
+  useMjmlConfigOptions?: boolean | undefined;
+  /**
+   * optional setting when inlining css, see mjml-cli documentation for more info
+   */
+  juicePreserveTags?: {
+    [index: string]: {
+      start: string;
+      end: string;
+    };
+  } | undefined;
+  juiceOptions?: any;
+  /**
+   * undocumented
+   * a function returning html skeleton
+   * default: see mjml-core/src/helpers/skeleton.js
+   */
+  skeleton?: string | (() => string) | undefined;
+  actualPath?: string | undefined;
+  /**
+   * undocumented
+   * ignore mj-include elements
+   * default: false
+   */
+  ignoreIncludes?: any;
+  /**
+   * see mjml-parser-xml
+   */
+  preprocessors?: Array<((xml: string) => string)> | undefined;
+  /**
+   * Add media queries specific to printer when converting mjml into html. When enabling this option,
+   * the html might not be compatible with all email clients anymore.
+   */
+  printerSupport?: boolean | undefined;
+}
+interface MJMLMinifyOptions {
+  collapseWhitespace?: boolean | undefined;
+  /**
+   * CSS minification options passed to cssnano-preset-lite.
+   * Accepts false (disable), true/'lite' (use lite preset), or a cssnano options object.
+   * @see https://cssnano.co/docs/presets
+   */
+  minifyCss?: boolean | "lite" | {
+    preset?: any;
+    plugins?: any[];
+    configFile?: string;
+  } | undefined;
+  /** @deprecated use minifyCss instead */
+  minifyCSS?: boolean | undefined;
+  removeEmptyAttributes?: boolean | undefined;
+  minifyJs?: boolean | undefined;
+  removeComments?: false | "safe" | "all" | undefined;
+}
+//#endregion
+//#region src/puppeteer/engines/pug/pug.service.d.ts
+type PugOptions = Options;
+declare class PugService {
+  render(template: string, data?: LocalsObject, options?: PugOptions): string;
+  renderFile(filePath: string, data?: LocalsObject, options?: PugOptions): string;
+}
+//#endregion
+//#region src/puppeteer/engines/ejs/ejs.service.d.ts
+interface EjsOptions extends Omit<Options$1, 'async'> {
+  async?: boolean;
+}
+declare class EjsService {
+  render(template: string, data?: Data, options?: EjsOptions): Promise<string>;
+  renderFile(filePath: string, data?: Data, options?: EjsOptions): Promise<string>;
+}
+//#endregion
+//#region src/puppeteer/engines/nunjucks/nunjucks.service.d.ts
+interface NunjucksOptions extends Partial<ConfigureOptions> {
+  noCache?: boolean;
+  watch?: boolean;
+  throwOnUndefined?: boolean;
+  trimBlocks?: boolean;
+  lstripBlocks?: boolean;
+}
+declare class NunjucksService {
+  constructor();
+  render(template: string, data?: Record<string, unknown>, options?: NunjucksOptions): string;
+  renderFile(filePath: string, data?: Record<string, unknown>, options?: NunjucksOptions): string;
+}
+//#endregion
+//#region src/puppeteer/engines/eta/eta.service.d.ts
+interface EtaOptions extends Partial<EtaConfig> {
+  cache?: boolean;
+  autoEscape?: boolean;
+  varName?: string;
+  views?: string;
+  useWith?: boolean;
+  plugins?: any[];
+}
+declare class EtaService {
+  private readonly eta;
+  private readonly templateCache;
+  private readonly maxCacheSize;
+  constructor();
+  /**
+   * Render an Eta template from a string
+   * @param template The template string to render
+   * @param data The data object to use for rendering
+   * @param options Optional Eta rendering options
+   * @returns The rendered HTML string
+   */
+  render(template: string, data?: Record<string, unknown>, options?: EtaOptions): string;
+  /**
+   * Render an Eta template from a file
+   * @param filePath The path to the template file
+   * @param data The data object to use for rendering
+   * @param options Optional Eta rendering options
+   * @returns The rendered HTML string
+   */
+  renderFile(filePath: string, data?: Record<string, unknown>, options?: EtaOptions): string;
+  /**
+   * Clear the template cache
+   */
+  clearCache(): void;
+  /**
+   * Get the current cache size
+   * @returns The number of cached templates
+   */
+  getCacheSize(): number;
+}
+//#endregion
+//#region src/puppeteer/engines/mustache/mustache.service.d.ts
+interface MustacheOptions {
+  tags?: [string, string];
+  escape?: EscapeFunction;
+}
+declare class MustacheService {
+  private readonly templateCache;
+  private readonly maxCacheSize;
+  /**
+   * Render a Mustache template from a string
+   * @param template The template string to render
+   * @param data The data object to use for rendering
+   * @param options Optional Mustache rendering options
+   * @returns The rendered HTML string
+   */
+  render(template: string, data?: Record<string, unknown>, options?: MustacheOptions): string;
+  /**
+   * Render a Mustache template from a file
+   * @param filePath The path to the template file
+   * @param data The data object to use for rendering
+   * @param options Optional Mustache rendering options
+   * @returns The rendered HTML string
+   */
+  renderFile(filePath: string, data?: Record<string, unknown>, options?: MustacheOptions): string;
+  /**
+   * Clear the template cache
+   */
+  clearCache(): void;
+  /**
+   * Get the current cache size
+   * @returns The number of cached templates
+   */
+  getCacheSize(): number;
+}
+//#endregion
+//#region src/puppeteer/puppeteer-parameters.interface.d.ts
+interface PuppeteerParameters {
+  pdfOptions?: PDFOptions;
+  hbsOptions?: HandlebarsOptions;
+  mjmlOptions?: MJMLParsingOptions;
+  pugOptions?: PugOptions;
+  ejsOptions?: EjsOptions;
+  nunjucksOptions?: NunjucksOptions;
+  etaOptions?: EtaOptions;
+  mustacheOptions?: MustacheOptions;
+  chromiumRevision?: string;
+  buildId?: string;
+  headless?: boolean | 'shell';
+  browser?: Browser;
+  browserTag?: BrowserTag;
+  useLockedBrowser?: boolean;
+  browserInstallBaseUrl?: string;
+  extraPuppeteerArgs?: string[];
+  executablePath?: string;
+  cleanupBrowserCacheOnExit?: boolean;
+}
+//#endregion
+//#region src/nestjs-pdf.module.d.ts
+interface PdfLibModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+  inject?: any[];
+  useFactory: (...args: any[]) => any;
+}
+declare class NestjsPdfModule {
+  static forRoot(options: PuppeteerParameters): DynamicModule;
+  static forRootAsync(options: PdfLibModuleAsyncOptions): DynamicModule;
+}
+//#endregion
+//#region src/puppeteer/engines/mjml/mjml.service.d.ts
+declare class MjmlService {
+  render(template: string, options?: MJMLParsingOptions): Promise<string>;
+  renderFile(filePath: string, options?: MJMLParsingOptions): Promise<string>;
+}
+//#endregion
+//#region src/puppeteer/puppeteer.service.d.ts
+declare class PuppeteerService {
+  private readonly browserService;
+  private readonly options;
+  private readonly hbsService?;
+  private readonly mjmlService?;
+  private readonly pugService?;
+  private readonly ejsService?;
+  private readonly nunjucksService?;
+  private readonly etaService?;
+  private readonly mustacheService?;
+  constructor(browserService: BrowserService, options: PuppeteerParameters, hbsService?: HandlebarsService | undefined, mjmlService?: MjmlService | undefined, pugService?: PugService | undefined, ejsService?: EjsService | undefined, nunjucksService?: NunjucksService | undefined, etaService?: EtaService | undefined, mustacheService?: MustacheService | undefined);
+  private readonly limit;
+  generatePdfFromHtml(html: string, options?: PuppeteerParameters): Promise<Uint8Array>;
+  generatePdfFromTemplateHbsString(template: string, parameters?: any, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromTemplateHbsFile(file: string, parameters?: any, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromMjmlString(template: string, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromMjmlFile(file: string, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromPugString(template: string, data?: LocalsObject, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromPugFile(file: string, data?: LocalsObject, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromEjsString(template: string, data?: Data, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromEjsFile(file: string, data?: Data, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromNunjucksString(template: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromNunjucksFile(file: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromEtaString(template: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromEtaFile(file: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromMustacheString(template: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  generatePdfFromMustacheFile(file: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+}
+//#endregion
+//#region src/nestjs-pdf.service.d.ts
+declare class NestjsPdfService {
+  private readonly puppeteerService;
+  constructor(puppeteerService: PuppeteerService);
+  /**
+   * @param html HTML string to convert to PDF
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided HTML
+   * @description This method uses the Puppeteer service to generate a PDF from an HTML string. Generation options can be customized by passing a `PuppeteerParameters` object as the second argument. This allows you to control various aspects of PDF rendering, such as page size, margins, background display, etc. If no options are provided, the default parameters defined in the Puppeteer service will be used.
+   */
+  generatePdfFromHtml(html: string, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param template Handlebars template string
+   * @param parameters Data parameters to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided Handlebars template with parameters applied
+   * @description This method generates a PDF from a Handlebars template provided as a string. The parameters to inject into the template are passed in the `parameters` object, which is used to render the template before converting it to PDF. PDF generation options can also be customized by passing a `PuppeteerParameters` object as the third argument. This allows you to control various aspects of PDF rendering, such as page size, margins, background display, etc. If no options are provided, the default parameters defined in the Puppeteer service will be used.
+   */
+  generatePdfFromTemplateHbsString(template: string, parameters?: any, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param file Path to the Handlebars template file
+   * @param parameters Data parameters to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the Handlebars template at the provided file path with parameters applied
+   * @description This method generates a PDF from a Handlebars template located at the specified file path. The file path is passed as a string in the `file` parameter. The parameters to inject into the template are passed in the `parameters` object, which is used to render the template before converting it to PDF. PDF generation options can also be customized by passing a `PuppeteerParameters` object as the third argument. This allows you to control various aspects of PDF rendering, such as page size, margins, background display, etc. If no options are provided, the default parameters defined in the Puppeteer service will be used.
+   */
+  generatePdfFromTemplateHbsFile(file: string, parameters?: any, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param template MJML template string
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided MJML template
+   * @description This method generates a PDF from an MJML template provided as a string. MJML (MJML Markup Language) is a markup language designed to reduce the pain of coding a responsive email. The template is first rendered to HTML using the MJML renderer, then converted to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the second argument.
+   */
+  generatePdfFromMjmlString(template: string, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param file Path to the MJML template file
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the MJML template at the provided file path
+   * @description This method generates a PDF from an MJML template located at the specified file path. The file path is passed as a string in the `file` parameter. The template is first rendered to HTML using the MJML renderer, then converted to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the second argument.
+   */
+  generatePdfFromMjmlFile(file: string, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param template EJS template string
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided EJS template with data applied
+   * @description This method generates a PDF from an EJS (Embedded JavaScript) template provided as a string. EJS is a templating language with a simple, straightforward syntax. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromEjsString(template: string, data?: Data, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param file Path to the EJS template file
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the EJS template at the provided file path with data applied
+   * @description This method generates a PDF from an EJS template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromEjsFile(file: string, data?: Data, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param template Pug template string
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided Pug template with data applied
+   * @description This method generates a PDF from a Pug template provided as a string. Pug is a clean, whitespace-sensitive syntax for writing HTML. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromPugString(template: string, data?: LocalsObject, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param file Path to the Pug template file
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the Pug template at the provided file path with data applied
+   * @description This method generates a PDF from a Pug template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromPugFile(file: string, data?: LocalsObject, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param template Nunjucks template string
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided Nunjucks template with data applied
+   * @description This method generates a PDF from a Nunjucks template provided as a string. Nunjucks is a powerful templating language with support for inheritance, macros, and filters. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromNunjucksString(template: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param file Path to the Nunjucks template file
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the Nunjucks template at the provided file path with data applied
+   * @description This method generates a PDF from a Nunjucks template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromNunjucksFile(file: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param template Eta template string
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided Eta template with data applied
+   * @description This method generates a PDF from an Eta template provided as a string. Eta is a fast and lightweight embedded templating language with a syntax similar to EJS but with better performance. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromEtaString(template: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param file Path to the Eta template file
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the Eta template at the provided file path with data applied
+   * @description This method generates a PDF from an Eta template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromEtaFile(file: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param template Mustache template string
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the provided Mustache template with data applied
+   * @description This method generates a PDF from a Mustache template provided as a string. Mustache is a logic-less template language that emphasizes readable and simple templates. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromMustacheString(template: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param file Path to the Mustache template file
+   * @param data Data to inject into the template
+   * @param options PDF generation options (optional)
+   * @returns PDF generated from the Mustache template at the provided file path with data applied
+   * @description This method generates a PDF from a Mustache template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+   */
+  generatePdfFromMustacheFile(file: string, data?: Record<string, unknown>, options?: PuppeteerParameters): Promise<Uint8Array<ArrayBufferLike>>;
+  /**
+   * @param pdf The PDF bytes to modify
+   * @param fieldName The name of the signature field to add (default: 'SignatureDebtor')
+   * @param anchorText The text anchor to locate the signature field position (default: '__SIG_DEBTOR_ANCHOR__')
+   * @returns Modified PDF with a signature field added at the anchor position
+   * @description This method adds a signature field to a PDF using a text anchor as a reference for the field position. It uses the `addSignatureFieldUsingAnchor` function which finds the anchor in the PDF and inserts a signature field at that location. The signature field is named according to the `fieldName` parameter and the anchor is defined by `anchorText`.
+   *
+   * Usage example:
+   * ```typescript
+   * const modifiedPdf = await pdfService.addSignatureFieldSignatureDebtorRaw(
+   *   originalPdfBytes,
+   *   'SignatureDebtor',
+   *   '__SIG_DEBTOR_ANCHOR__'
+   * );
+   * ```
+   *
+   * In this example, `originalPdfBytes` is a byte array representing the original PDF, `SignatureDebtor` is the name of the signature field to add, and `__SIG_DEBTOR_ANCHOR__` is the anchor text used to position the signature field in the PDF.
+   *
+   * If the anchor is not found, the signature field will be added at a default position (centered at the bottom of the last page).
+   *
+   * Note: Ensure that the input PDF contains the anchor defined by `anchorText` for the signature field to be positioned correctly. Otherwise, it will be added at a default position.
+   */
+  addSignatureFieldSignatureDebtorRaw(pdf: Uint8Array | Buffer, fieldName?: string, anchorText?: string): Promise<Uint8Array<ArrayBufferLike>>;
+}
+//#endregion
+//#region src/puppeteer/puppeteer.module.d.ts
+interface PuppeteerModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+  inject?: (InjectionToken | OptionalFactoryDependency)[];
+  useFactory: (...args: any[]) => Promise<PuppeteerParameters> | PuppeteerParameters;
+}
+declare class PuppeteerModule implements OnModuleInit {
+  private readonly browserService;
+  private readonly pdfParams;
+  constructor(browserService: BrowserService, pdfParams: PuppeteerParameters);
+  onModuleInit(): Promise<void>;
+  static forRoot(pdfParameters: PuppeteerParameters): DynamicModule;
+  static forRootAsync(options: PuppeteerModuleAsyncOptions): DynamicModule;
+}
+//#endregion
+//#region src/helpers/getRelativePath.helper.d.ts
+/**
+ * Get the relative path to a value from the module directory.
+ * @param moduleDir the path of the module, typically __dirname
+ * @param relativeToModule the path to the value relative to the module directory
+ * @returns the relative path from the current working directory to the value
+ * @example
+ * getRelativePathToValue(__dirname, './templates/my-template.hbs');
+ * // returns 'context/pdf/templates/my-template.hbs' if the current working directory is '/
+ */
+declare function getRelativePathToValue(moduleDir: string, relativeToModule: string): string;
+//#endregion
+export { EjsOptions, EjsService, EtaOptions, EtaService, MjmlService, MustacheOptions, MustacheService, NestjsPdfModule, NestjsPdfService, NunjucksOptions, NunjucksService, PdfLibModuleAsyncOptions, PugOptions, PugService, PuppeteerModule, PuppeteerModuleAsyncOptions, PuppeteerParameters, PuppeteerService, getRelativePathToValue };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/puppeteer/browser/browser.service.ts","../node_modules/.pnpm/@types+mjml-core@5.1.0/node_modules/@types/mjml-core/index.d.ts","../src/puppeteer/engines/pug/pug.service.ts","../src/puppeteer/engines/ejs/ejs.service.ts","../src/puppeteer/engines/nunjucks/nunjucks.service.ts","../src/puppeteer/engines/eta/eta.service.ts","../src/puppeteer/engines/mustache/mustache.service.ts","../src/puppeteer/puppeteer-parameters.interface.ts","../src/nestjs-pdf.module.ts","../src/puppeteer/engines/mjml/mjml.service.ts","../src/puppeteer/puppeteer.service.ts","../src/nestjs-pdf.service.ts","../src/puppeteer/puppeteer.module.ts","../src/helpers/getRelativePath.helper.ts"],"x_google_ignoreList":[1],"mappings":"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"}