@aurabase/aurabase-js 0.3.1 → 0.4.0

package/packages/gen/dist/index.js

@@ -1,255 +0,0 @@
-// src/generate.ts
-function enumRef(name, ctx) {
-  return ctx.enumNames.has(name) ? `${ctx.typeName}['${ctx.schemaName}']['Enums']['${name}']` : (
-    // Enum inconnu du bloc Enums → auto-référence non résoluble → repli textuel.
-    "string"
-  );
-}
-function mapColType(colType, ctx) {
-  if (typeof colType === "string") {
-    switch (colType) {
-      case "text":
-      case "varchar":
-      case "bpchar":
-      case "uuid":
-      case "timestamp":
-      case "timestamptz":
-      case "date":
-      case "time":
-      case "bytea":
-      case "numeric":
-        return "string";
-      case "int":
-      case "int2":
-      case "int4":
-      case "int8":
-      case "bigint":
-      case "float":
-      case "float4":
-      case "float8":
-        return "number";
-      case "bool":
-        return "boolean";
-      case "json":
-      case "jsonb":
-        return "Json";
-      default:
-        return "unknown";
-    }
-  }
-  if (colType && typeof colType === "object") {
-    if ("array" in colType) return `${mapColType(colType.array, ctx)}[]`;
-    if ("vector" in colType) return "number[]";
-    if ("enum" in colType) return enumRef(String(colType.enum), ctx);
-  }
-  return "unknown";
-}
-function mapPgType(raw, ctx) {
-  if (raw.startsWith("_")) return `${mapPgType(raw.slice(1), ctx)}[]`;
-  switch (raw) {
-    case "int2":
-    case "int4":
-    case "int8":
-    case "float4":
-    case "float8":
-      return "number";
-    case "numeric":
-      return "string";
-    case "bool":
-      return "boolean";
-    case "text":
-    case "varchar":
-    case "bpchar":
-    case "citext":
-    case "uuid":
-    case "date":
-    case "time":
-    case "timetz":
-    case "timestamp":
-    case "timestamptz":
-    case "bytea":
-      return "string";
-    case "json":
-    case "jsonb":
-      return "Json";
-    case "void":
-      return "undefined";
-    case "record":
-      return "unknown";
-    default:
-      return ctx.enumNames.has(raw) ? enumRef(raw, ctx) : "unknown";
-  }
-}
-function tsType(col, ctx) {
-  const base = mapColType(col.col_type, ctx);
-  return col.nullable ? `${base} | null` : base;
-}
-function genRow(cols, ctx) {
-  return cols.map((c) => `          ${c.name}: ${tsType(c, ctx)}`).join("\n");
-}
-var AUTO_COLS = /* @__PURE__ */ new Set(["id", "created_at", "updated_at"]);
-function isInsertOptional(col) {
-  return col.nullable || col.default_val != null || AUTO_COLS.has(col.name);
-}
-function genInsert(cols, ctx) {
-  return cols.map((c) => `          ${c.name}${isInsertOptional(c) ? "?" : ""}: ${tsType(c, ctx)}`).join("\n");
-}
-function genUpdate(cols, ctx) {
-  return cols.map((c) => `          ${c.name}?: ${tsType(c, ctx)}`).join("\n");
-}
-function genRelationships(t) {
-  const fks = t.columns.filter((c) => c.references);
-  if (fks.length === 0) return "[]";
-  const groups = /* @__PURE__ */ new Map();
-  for (const c of fks) {
-    const ref = c.references;
-    const name = ref.constraint_name ?? `${t.name}_${c.name}_fkey`;
-    const key = ref.constraint_name ?? `\0synthetic\0${c.name}`;
-    let g = groups.get(key);
-    if (!g) {
-      g = { name, columns: [], refTable: ref.table, refColumns: [], cols: [] };
-      groups.set(key, g);
-    }
-    g.columns.push(c.name);
-    g.refColumns.push(ref.column);
-    g.cols.push(c);
-  }
-  const entries = [...groups.values()].map((g) => {
-    const isOneToOne = g.cols.every((c) => c.unique || t.primary_key === c.name);
-    const cols = g.columns.map((c) => `'${c}'`).join(", ");
-    const refCols = g.refColumns.map((c) => `'${c}'`).join(", ");
-    return `          {
-            foreignKeyName: '${g.name}'
-            columns: [${cols}]
-            isOneToOne: ${isOneToOne}
-            referencedRelation: '${g.refTable}'
-            referencedColumns: [${refCols}]
-          }`;
-  });
-  return `[
-${entries.join(",\n")}
-        ]`;
-}
-function genFunctionArgs(fn, ctx) {
-  const inputArgs = fn.args.filter((a) => a.mode.toUpperCase() !== "OUT");
-  if (inputArgs.length === 0) return "Record<string, never>";
-  const entries = inputArgs.map((a) => `${a.name}: ${mapPgType(a.data_type, ctx)}`).join("; ");
-  return `{ ${entries} }`;
-}
-function mapReturnType(fn, ctx) {
-  const base = mapPgType(fn.returns, ctx);
-  if (!fn.is_set_returning) return base;
-  return base === "unknown" ? "Record<string, unknown>[]" : `${base}[]`;
-}
-function genSetofOptions(fn, ctx) {
-  if (!fn.is_set_returning) return null;
-  const to = ctx.relationNames.has(fn.returns) ? fn.returns : fn.name;
-  return `{ isSetofReturn: true; isOneToOne: false; to: '${to}'; from: '*' }`;
-}
-function genFunctionsBody(functions, ctx) {
-  if (functions.length === 0) return "Record<string, never>";
-  const groups = /* @__PURE__ */ new Map();
-  for (const fn of functions) {
-    const g = groups.get(fn.name);
-    if (g) g.push(fn);
-    else groups.set(fn.name, [fn]);
-  }
-  const entries = [...groups.values()].map((overloads) => {
-    const argsUnion = uniq(overloads.map((fn) => genFunctionArgs(fn, ctx))).join(" | ");
-    const returnsUnion = uniq(overloads.map((fn) => mapReturnType(fn, ctx))).join(" | ");
-    const lines = [
-      `      ${overloads[0].name}: {`,
-      `        Args: ${argsUnion}`,
-      `        Returns: ${returnsUnion}`
-    ];
-    if (overloads.length === 1) {
-      const setofOptions = genSetofOptions(overloads[0], ctx);
-      if (setofOptions) lines.push(`        SetofOptions: ${setofOptions}`);
-    }
-    lines.push("      }");
-    return lines.join("\n");
-  });
-  return `{
-${entries.join("\n")}
-    }`;
-}
-function uniq(items) {
-  return [...new Set(items)];
-}
-function genEnumsBody(enums) {
-  if (enums.length === 0) return "Record<string, never>";
-  const entries = enums.map((e) => {
-    const union = e.values.length === 0 ? "never" : e.values.map((v) => `'${v}'`).join(" | ");
-    return `      ${e.name}: ${union}`;
-  });
-  return `{
-${entries.join("\n")}
-    }`;
-}
-function genViewsBody(views, ctx) {
-  if (views.length === 0) return "Record<string, never>";
-  const entries = views.map(
-    (v) => `      ${v.name}: {
-        Row: {
-${genRow(v.columns, ctx)}
-        }
-        Relationships: []
-      }`
-  );
-  return `{
-${entries.join("\n")}
-    }`;
-}
-var HEADER = `// ============================================================
-// Types TypeScript auto-g\xE9n\xE9r\xE9s par Aurabase (@aurabase/gen)
-// NE PAS MODIFIER \u2014 r\xE9g\xE9n\xE9rer avec \`npx @aurabase/gen\`
-// ============================================================
-`;
-function generateDatabaseTypes(tables, options = {}) {
-  const schemaName = options.schemaName ?? "public";
-  const typeName = options.typeName ?? "Database";
-  const enums = options.enums ?? [];
-  const views = options.views ?? [];
-  const relationNames = new Set([...tables, ...views].map((r) => r.name));
-  const ctx = { typeName, schemaName, enumNames: new Set(enums.map((e) => e.name)), relationNames };
-  const functionsBody = genFunctionsBody(options.functions ?? [], ctx);
-  const enumsBody = genEnumsBody(enums);
-  const viewsBody = genViewsBody(views, ctx);
-  const tablesBody = tables.length === 0 ? "Record<string, never>" : `{
-${tables.map(
-    (t) => `      ${t.name}: {
-        Row: {
-${genRow(t.columns, ctx)}
-        }
-        Insert: {
-${genInsert(t.columns, ctx)}
-        }
-        Update: {
-${genUpdate(t.columns, ctx)}
-        }
-        Relationships: ${genRelationships(t)}
-      }`
-  ).join("\n")}
-    }`;
-  return `${HEADER}
-export type Json =
-  | string
-  | number
-  | boolean
-  | null
-  | { [key: string]: Json | undefined }
-  | Json[]
-
-export interface ${typeName} {
-  ${schemaName}: {
-    Tables: ${tablesBody}
-    Views: ${viewsBody}
-    Functions: ${functionsBody}
-    Enums: ${enumsBody}
-    CompositeTypes: Record<string, never>
-  }
-}
-`;
-}
-
-export { generateDatabaseTypes };

package/packages/gen/package.json

@@ -1,66 +0,0 @@
-{
-  "name": "@aurabase/gen",
-  "version": "0.3.0",
-  "description": "Générateur de types TypeScript Database pour le SDK Aurabase (CLI aurabase-gen)",
-  "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "aurabase-gen": "./dist/cli.js"
-  },
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
-  },
-  "sideEffects": false,
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "license": "MIT",
-  "author": "Aurabase",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/daylami555/aurabase.git",
-    "directory": "aurabase-js/packages/gen"
-  },
-  "homepage": "https://github.com/daylami555/aurabase/tree/main/aurabase-js/packages/gen#readme",
-  "bugs": {
-    "url": "https://github.com/daylami555/aurabase/issues"
-  },
-  "keywords": [
-    "aurabase",
-    "baas",
-    "sdk",
-    "generator",
-    "types"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "test": "vitest run --passWithNoTests",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@aurabase/core": "workspace:*",
-    "aurabase": "workspace:*"
-  },
-  "devDependencies": {
-    "tsup": "catalog:",
-    "typescript": "catalog:",
-    "vitest": "catalog:",
-    "@types/node": "catalog:"
-  }
-}

package/packages/notifications/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Aurabase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/packages/notifications/README.md

@@ -1,134 +0,0 @@
-# @aurabase/notifications
-
-Service de notifications multi-canal du SDK Aurabase : email, SMS, push et webhook derrière une API unique, avec templates, règles déclenchées par événement et administration complète (`aura.notifications.admin`).
-
-![npm](https://img.shields.io/npm/v/@aurabase/notifications) ![license](https://img.shields.io/badge/license-MIT-blue)
-
-> Pre-release — pas encore publié sur npm.
-
-Fait partie du SDK **[aurabase](../aurabase)**. Installé automatiquement avec `aurabase` ; ce package est publié séparément pour un usage ciblé / tree-shaking.
-
-Le multi-canal unifié (un seul `send()` pour email/SMS/push/webhook, avec dead-letter, retries et règles) est un **différenciateur** face à des solutions push-only (FCM) ou tiers payantes (OneSignal).
-
-## Installation
-
-```bash
-npm i @aurabase/notifications
-```
-
-> Ce package dépend de `@aurabase/core` (`workspace:*` en interne, résolu en semver côté npm). Si vous utilisez déjà le package `aurabase`, `@aurabase/notifications` est déjà inclus — cette installation ciblée n'est utile que pour composer votre propre client ou limiter la taille du bundle.
-
-## Usage
-
-Dans l'usage courant, `NotificationsService` n'est jamais instancié directement : il est exposé par le client principal sous `aura.notifications` (et son admin sous `aura.notifications.admin`).
-
-```ts
-import { createClient } from 'aurabase'
-
-const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-```
-
-### Envoi
-
-Canaux disponibles : `'email' | 'sms' | 'push' | 'webhook'`.
-
-```ts
-const { data, error } = await aura.notifications.send(
-  'email',
-  'user@example.com',
-  'Votre commande a été expédiée.',
-  { subject: 'Expédition', variables: { order_id: '1234' }, idempotencyKey: 'order-1234-shipped' },
-)
-
-if (error) throw error
-console.log(data!.status)
-```
-
-### Envoi en lot
-
-```ts
-const { data: batch } = await aura.notifications.sendBatch([
-  { channel: 'email', recipient: 'a@example.com', body: 'Bonjour A' },
-  { channel: 'sms', recipient: '+15551234567', body: 'Bonjour B' },
-])
-
-for (const item of batch!.items) {
-  console.log(item.status, item.notification?.id)
-}
-```
-
-### Historique et templates
-
-```ts
-const { data: sent } = await aura.notifications.list({
-  channel: 'email',
-  status: 'delivered',
-  sort: 'created_at',
-  order: 'desc',
-  limit: 20,
-})
-
-const notificationId = sent![0]!.id
-const { data: notif } = await aura.notifications.get(notificationId)
-
-const { data: template } = await aura.notifications.createTemplate({
-  name: 'order-shipped',
-  channel: 'email',
-  subject: 'Expédition {{order_id}}',
-  body: 'Votre commande {{order_id}} est en route.',
-  variables: ['order_id'],
-})
-
-await aura.notifications.updateTemplate(template!.id, { body: 'Mise à jour : {{order_id}} expédiée.' })
-```
-
-### Administration (`aura.notifications.admin`)
-
-```ts
-const { data: settings } = await aura.notifications.admin.getSettings()
-await aura.notifications.admin.updateSettings({ quotas: { daily_email: 10000 } })
-
-const { data: stats } = await aura.notifications.admin.getStats({ window: '24h', channel: 'email' })
-const { data: queue } = await aura.notifications.admin.getQueue()
-
-const failedId = 'notification-id'
-const { data: attempts } = await aura.notifications.admin.listAttempts(failedId)
-
-const { data: deadLetters } = await aura.notifications.admin.listDeadLetters({ channel: 'email', limit: 50 })
-await aura.notifications.admin.retryDeadLetter(deadLetters![0]!.id)
-
-const { data: events } = await aura.notifications.admin.listEvents({ status: 'failed' })
-const { data: logs } = await aura.notifications.admin.listProviderLogs({ channel: 'sms' })
-
-const templateId = 'template-id'
-const { data: preview } = await aura.notifications.admin.previewTemplate(templateId, { order_id: '1234' })
-console.log(preview!.subject, preview!.body)
-```
-
-### Règles déclenchées par événement
-
-```ts
-const { data: rule } = await aura.notifications.admin.createRule({
-  name: 'welcome-email',
-  trigger_type: 'user.created',
-  channel: 'email',
-  recipient_expr: 'user.email',
-  template_id: 'welcome-template-id',
-  delay_seconds: 0,
-})
-
-const { data: rules } = await aura.notifications.admin.listRules()
-await aura.notifications.admin.updateRule(rule!.id, { enabled: false })
-await aura.notifications.admin.deleteRule(rule!.id)
-```
-
-## Limitations
-
-- Pas de gestion d'audience/segments/devices : `recipient` est une chaîne brute (email, numéro, endpoint webhook, device token) — pas d'abstraction "device" ou "utilisateur" côté SDK.
-- Pas de scheduling explicite d'un envoi (« envoyer à telle date ») en dehors du `delay_seconds` des règles déclenchées.
-- Payloads génériques : `body` est une chaîne libre associée à des `variables` (interpolation côté backend), pas un objet structuré par canal (pas de builder push spécifique avec badge/son/icône, par exemple).
-- Pas d'API de désabonnement/préférences par canal exposée par le SDK.
-
-## Documentation
-
-Référence complète du SDK (tous les services, types partagés, SSR) : [README racine](../../README.md).

package/packages/notifications/dist/index.cjs

@@ -1,128 +0,0 @@
-'use strict';
-
-var core = require('@aurabase/core');
-
-// src/NotificationsService.ts
-var NotificationsService = class extends core.BaseService {
-  admin;
-  constructor(client) {
-    super(client);
-    this.admin = new NotificationsAdminService(client);
-  }
-  get prefix() {
-    return `/v1/notifications/${this.client.projectId}`;
-  }
-  // -- Send -------------------------------------------------------------------
-  async send(channel, recipient, body, options) {
-    return this.request("POST", `${this.prefix}/send`, {
-      channel,
-      recipient,
-      body,
-      subject: options?.subject,
-      template_id: options?.templateId,
-      variables: options?.variables,
-      metadata: options?.metadata,
-      idempotency_key: options?.idempotencyKey
-    });
-  }
-  async sendBatch(items) {
-    return this.request("POST", `${this.prefix}/send/batch`, { items });
-  }
-  // -- Notification history ---------------------------------------------------
-  async list(options) {
-    const params = new URLSearchParams();
-    if (options?.channel !== void 0) params.set("channel", options.channel);
-    if (options?.status !== void 0) params.set("status", options.status);
-    if (options?.search !== void 0) params.set("search", options.search);
-    if (options?.sort !== void 0) params.set("sort", options.sort);
-    if (options?.order !== void 0) params.set("order", options.order);
-    if (options?.limit !== void 0) params.set("limit", String(options.limit));
-    if (options?.offset !== void 0) params.set("offset", String(options.offset));
-    const qs = params.toString();
-    const sep = qs ? "?" : "";
-    return this.request("GET", `${this.prefix}${sep}${qs}`);
-  }
-  async get(id) {
-    return this.request("GET", `${this.prefix}/${id}`);
-  }
-  // -- Templates --------------------------------------------------------------
-  async listTemplates() {
-    return this.request("GET", `${this.prefix}/templates`);
-  }
-  async getTemplate(id) {
-    return this.request("GET", `${this.prefix}/templates/${id}`);
-  }
-  async createTemplate(template) {
-    return this.request("POST", `${this.prefix}/templates`, template);
-  }
-  async updateTemplate(id, updates) {
-    return this.request("PATCH", `${this.prefix}/templates/${id}`, updates);
-  }
-  async deleteTemplate(id) {
-    return this.request("DELETE", `${this.prefix}/templates/${id}`);
-  }
-};
-var NotificationsAdminService = class extends core.BaseService {
-  constructor(client) {
-    super(client);
-  }
-  get prefix() {
-    return `/v1/notifications/${this.client.projectId}`;
-  }
-  query(options) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(options ?? {})) {
-      if (value !== void 0 && value !== null && value !== "") params.set(key, String(value));
-    }
-    const qs = params.toString();
-    return qs ? `?${qs}` : "";
-  }
-  async getSettings() {
-    return this.request("GET", `${this.prefix}/settings`);
-  }
-  async updateSettings(settings) {
-    return this.request("PATCH", `${this.prefix}/settings`, settings);
-  }
-  async getStats(options) {
-    return this.request("GET", `${this.prefix}/stats${this.query(options)}`);
-  }
-  async getQueue() {
-    return this.request("GET", `${this.prefix}/queue`);
-  }
-  async listAttempts(notificationId) {
-    return this.request("GET", `${this.prefix}/${notificationId}/attempts`);
-  }
-  async listDeadLetters(options) {
-    return this.request("GET", `${this.prefix}/dead-letters${this.query(options)}`);
-  }
-  async retryDeadLetter(id) {
-    return this.request("POST", `${this.prefix}/dead-letters/${id}/retry`);
-  }
-  async listEvents(options) {
-    return this.request("GET", `${this.prefix}/events${this.query(options)}`);
-  }
-  async listProviderLogs(options) {
-    return this.request("GET", `${this.prefix}/providers/logs${this.query(options)}`);
-  }
-  async previewTemplate(id, variables) {
-    return this.request("POST", `${this.prefix}/templates/${id}/preview`, variables);
-  }
-  async listRules() {
-    return this.request("GET", `${this.prefix}/rules`);
-  }
-  async createRule(rule) {
-    return this.request("POST", `${this.prefix}/rules`, rule);
-  }
-  async getRule(id) {
-    return this.request("GET", `${this.prefix}/rules/${id}`);
-  }
-  async updateRule(id, updates) {
-    return this.request("PATCH", `${this.prefix}/rules/${id}`, updates);
-  }
-  async deleteRule(id) {
-    return this.request("DELETE", `${this.prefix}/rules/${id}`);
-  }
-};
-
-exports.NotificationsAdminService = NotificationsAdminService;
-exports.NotificationsService = NotificationsService;

package/packages/notifications/dist/index.d.cts

@@ -1,81 +0,0 @@
-import { BaseService, AuraClientLike, AuraResponse, NotificationSettings, NotificationStats, NotificationQueueStats, NotificationAttempt, NotificationDeadLetter, Notification, NotificationEvent, NotificationProviderLog, NotificationTemplatePreview, NotificationRule, SendNotificationRequest, BatchSendResponse, NotificationTemplate } from '@aurabase/core';
-export { AuraResponse, BatchSendResponse, Notification, NotificationAttempt, NotificationDeadLetter, NotificationEvent, NotificationProviderLog, NotificationQueueStats, NotificationRule, NotificationSettings, NotificationStats, NotificationTemplate, NotificationTemplatePreview, SendNotificationRequest } from '@aurabase/core';
-
-type NotificationChannel = 'email' | 'sms' | 'push' | 'webhook';
-type NotificationStatus = 'queued' | 'processing' | 'sent' | 'failed' | 'delivered' | 'expired' | 'dead_lettered';
-type CreateNotificationRuleRequest = {
-    name: string;
-    trigger_type: string;
-    condition?: Record<string, unknown>;
-    template_id?: string | null;
-    channel: NotificationChannel;
-    recipient_expr: string;
-    delay_seconds?: number;
-};
-declare class NotificationsService extends BaseService {
-    readonly admin: NotificationsAdminService;
-    constructor(client: AuraClientLike);
-    private get prefix();
-    send(channel: NotificationChannel, recipient: string, body: string, options?: {
-        subject?: string;
-        templateId?: string;
-        variables?: Record<string, unknown>;
-        metadata?: Record<string, unknown>;
-        idempotencyKey?: string;
-    }): Promise<AuraResponse<Notification>>;
-    sendBatch(items: SendNotificationRequest[]): Promise<AuraResponse<BatchSendResponse>>;
-    list(options?: {
-        channel?: NotificationChannel;
-        status?: NotificationStatus;
-        search?: string;
-        sort?: 'created_at' | 'updated_at' | 'status';
-        order?: 'asc' | 'desc';
-        limit?: number;
-        offset?: number;
-    }): Promise<AuraResponse<Notification[]>>;
-    get(id: string): Promise<AuraResponse<Notification>>;
-    listTemplates(): Promise<AuraResponse<NotificationTemplate[]>>;
-    getTemplate(id: string): Promise<AuraResponse<NotificationTemplate>>;
-    createTemplate(template: Omit<NotificationTemplate, 'id' | 'created_at' | 'updated_at'>): Promise<AuraResponse<NotificationTemplate>>;
-    updateTemplate(id: string, updates: Partial<Omit<NotificationTemplate, 'id' | 'created_at' | 'updated_at'>>): Promise<AuraResponse<NotificationTemplate>>;
-    deleteTemplate(id: string): Promise<AuraResponse<null>>;
-}
-declare class NotificationsAdminService extends BaseService {
-    constructor(client: AuraClientLike);
-    private get prefix();
-    private query;
-    getSettings(): Promise<AuraResponse<NotificationSettings>>;
-    updateSettings(settings: Partial<NotificationSettings>): Promise<AuraResponse<NotificationSettings>>;
-    getStats(options?: {
-        window?: string;
-        channel?: NotificationChannel;
-    }): Promise<AuraResponse<NotificationStats>>;
-    getQueue(): Promise<AuraResponse<NotificationQueueStats>>;
-    listAttempts(notificationId: string): Promise<AuraResponse<NotificationAttempt[]>>;
-    listDeadLetters(options?: {
-        channel?: NotificationChannel;
-        search?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<AuraResponse<NotificationDeadLetter[]>>;
-    retryDeadLetter(id: string): Promise<AuraResponse<Notification>>;
-    listEvents(options?: {
-        status?: 'received' | 'matched' | 'ignored' | 'failed' | 'enqueued';
-        limit?: number;
-        offset?: number;
-    }): Promise<AuraResponse<NotificationEvent[]>>;
-    listProviderLogs(options?: {
-        channel?: NotificationChannel;
-        status?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<AuraResponse<NotificationProviderLog[]>>;
-    previewTemplate(id: string, variables: Record<string, unknown>): Promise<AuraResponse<NotificationTemplatePreview>>;
-    listRules(): Promise<AuraResponse<NotificationRule[]>>;
-    createRule(rule: CreateNotificationRuleRequest): Promise<AuraResponse<NotificationRule>>;
-    getRule(id: string): Promise<AuraResponse<NotificationRule>>;
-    updateRule(id: string, updates: Partial<Omit<NotificationRule, 'id' | 'project_id' | 'created_at' | 'updated_at'>>): Promise<AuraResponse<NotificationRule>>;
-    deleteRule(id: string): Promise<AuraResponse<null>>;
-}
-
-export { NotificationsAdminService, NotificationsService };