@notifica/node 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1912 @@
+interface PaginationParams {
+    /** Máximo por página (default: 20, max: 100) */
+    limit?: number;
+    /** Cursor de paginação retornado na resposta anterior */
+    cursor?: string;
+}
+interface PaginationMeta {
+    cursor: string | null;
+    has_more: boolean;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+interface SingleResponse<T> {
+    data: T;
+}
+interface ApiErrorBody {
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, string[]>;
+    };
+}
+type Channel = 'email' | 'whatsapp' | 'sms' | 'in_app' | 'push';
+type NotificationStatus = 'pending' | 'processing' | 'delivered' | 'failed' | 'bounced' | 'rejected';
+type TemplateStatus = 'draft' | 'active';
+type Environment = 'production' | 'sandbox';
+type ApiKeyType = 'secret' | 'public';
+interface RequestOptions {
+    /** Chave de idempotência customizada para requests POST */
+    idempotencyKey?: string;
+    /** Timeout em milissegundos para esta request específica */
+    timeout?: number;
+    /** Signal para abortar a request */
+    signal?: AbortSignal;
+}
+
+interface NotificaClientConfig {
+    /** API key (nk_live_..., nk_test_..., pk_live_..., pk_test_...) */
+    apiKey: string;
+    /** Base URL da API (default: https://app.usenotifica.com.br/v1) */
+    baseUrl?: string;
+    /** Timeout padrão em ms (default: 30000) */
+    timeout?: number;
+    /** Máximo de retries em 429/5xx (default: 3) */
+    maxRetries?: number;
+    /** Gerar idempotency key automaticamente para POSTs (default: true) */
+    autoIdempotency?: boolean;
+}
+declare class NotificaClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly autoIdempotency;
+    constructor(config: NotificaClientConfig);
+    get<T>(path: string, query?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T = void>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Lista com paginação manual.
+     * Retorna { data, meta } com cursor para próxima página.
+     */
+    list<T>(path: string, query?: Record<string, unknown>, options?: RequestOptions): Promise<PaginatedResponse<T>>;
+    /**
+     * Async iterator para auto-paginação.
+     *
+     * @example
+     * ```ts
+     * for await (const notification of client.paginate<Notification>('/notifications')) {
+     *   console.log(notification.id);
+     * }
+     * ```
+     */
+    paginate<T>(path: string, query?: Record<string, unknown>): AsyncIterableIterator<T>;
+    /**
+     * Wrapper para respostas { data: T }.
+     */
+    getOne<T>(path: string, options?: RequestOptions): Promise<T>;
+    private request;
+    private buildUrl;
+    private buildHeaders;
+    private generateIdempotencyKey;
+    private backoff;
+    private parseRetryAfter;
+    private safeParseJson;
+}
+
+interface SendNotificationParams {
+    /** Canal de entrega */
+    channel: Channel;
+    /** Destinatário (email, telefone E.164, subscriber_id, etc.) */
+    to: string;
+    /** Slug do template para renderizar */
+    template?: string;
+    /** Variáveis para o template ou conteúdo direto */
+    data?: Record<string, unknown>;
+    /** Metadados arbitrários (não processados) */
+    metadata?: Record<string, unknown>;
+}
+interface Notification {
+    id: string;
+    channel: Channel;
+    recipient: string;
+    status: NotificationStatus;
+    template_id?: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at?: string;
+}
+interface MessageAttempt {
+    id: string;
+    attempt_number: number;
+    status: string;
+    provider_response?: Record<string, unknown>;
+    created_at: string;
+}
+interface ListNotificationsParams extends PaginationParams {
+    /** Filtrar por status */
+    status?: NotificationStatus;
+    /** Filtrar por canal */
+    channel?: Channel;
+}
+
+declare class Notifications {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Envia uma notificação.
+     * A notificação é enfileirada para entrega assíncrona.
+     *
+     * @example
+     * ```ts
+     * const notification = await notifica.notifications.send({
+     *   channel: 'whatsapp',
+     *   to: '+5511999999999',
+     *   template: 'welcome',
+     *   data: { name: 'João' },
+     * });
+     * ```
+     */
+    send(params: SendNotificationParams, options?: RequestOptions): Promise<Notification>;
+    /**
+     * Lista notificações com paginação.
+     *
+     * @example
+     * ```ts
+     * const { data, meta } = await notifica.notifications.list({ channel: 'email', limit: 50 });
+     * ```
+     */
+    list(params?: ListNotificationsParams, options?: RequestOptions): Promise<PaginatedResponse<Notification>>;
+    /**
+     * Itera automaticamente por todas as notificações.
+     *
+     * @example
+     * ```ts
+     * for await (const notification of notifica.notifications.listAll({ channel: 'email' })) {
+     *   console.log(notification.id);
+     * }
+     * ```
+     */
+    listAll(params?: Omit<ListNotificationsParams, 'cursor'>): AsyncIterableIterator<Notification>;
+    /**
+     * Obtém detalhes de uma notificação.
+     */
+    get(id: string, options?: RequestOptions): Promise<Notification>;
+    /**
+     * Lista tentativas de entrega de uma notificação.
+     */
+    listAttempts(notificationId: string, options?: RequestOptions): Promise<MessageAttempt[]>;
+}
+
+interface CreateTemplateParams {
+    /** Canal alvo */
+    channel: Channel;
+    /** Identificador URL-safe */
+    slug: string;
+    /** Nome legível */
+    name: string;
+    /** Conteúdo com {{variáveis}} */
+    content: string;
+    /** Lista de variáveis (auto-extraída se omitida) */
+    variables?: string[];
+    /** Variantes por canal (subject, html_body, etc.) */
+    variants?: Record<string, string>;
+    /** Idioma (default: pt_BR) */
+    language?: string;
+    /** Status (default: draft) */
+    status?: TemplateStatus;
+    /** Metadados extras */
+    metadata?: Record<string, unknown>;
+    /** Referência a template externo */
+    provider_template_id?: string;
+}
+interface UpdateTemplateParams {
+    name?: string;
+    content?: string;
+    variables?: string[];
+    variants?: Record<string, string>;
+    language?: string;
+    status?: TemplateStatus;
+    metadata?: Record<string, unknown>;
+    provider_template_id?: string;
+}
+interface Template {
+    id: string;
+    slug: string;
+    name: string;
+    channel: Channel;
+    content: string;
+    variables: string[];
+    variants?: Record<string, string>;
+    language: string;
+    status: TemplateStatus;
+    metadata?: Record<string, unknown>;
+    provider_template_id?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface PreviewTemplateParams {
+    variables: Record<string, unknown>;
+}
+interface PreviewContentParams {
+    content: string;
+    channel: Channel;
+    variables?: Record<string, unknown>;
+    variants?: Record<string, string>;
+}
+interface PreviewResult {
+    rendered: Record<string, string>;
+    variables: string[];
+    validation: ValidationResult;
+}
+interface ValidateContentParams {
+    content: string;
+    channel: Channel;
+    variants?: Record<string, string>;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    variables?: string[];
+}
+interface ListTemplatesParams extends PaginationParams {
+    /** Filtrar por canal */
+    channel?: Channel;
+    /** Filtrar por status */
+    status?: TemplateStatus;
+}
+
+declare class Templates {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Cria um novo template.
+     *
+     * @example
+     * ```ts
+     * const template = await notifica.templates.create({
+     *   channel: 'email',
+     *   slug: 'welcome-email',
+     *   name: 'Email de Boas-Vindas',
+     *   content: 'Olá {{name}}, bem-vindo!',
+     * });
+     * ```
+     */
+    create(params: CreateTemplateParams, options?: RequestOptions): Promise<Template>;
+    /**
+     * Lista templates com paginação.
+     */
+    list(params?: ListTemplatesParams, options?: RequestOptions): Promise<PaginatedResponse<Template>>;
+    /**
+     * Itera automaticamente por todos os templates.
+     */
+    listAll(params?: Omit<ListTemplatesParams, 'cursor'>): AsyncIterableIterator<Template>;
+    /**
+     * Obtém detalhes de um template.
+     */
+    get(id: string, options?: RequestOptions): Promise<Template>;
+    /**
+     * Atualiza um template.
+     */
+    update(id: string, params: UpdateTemplateParams, options?: RequestOptions): Promise<Template>;
+    /**
+     * Deleta um template.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Preview de um template salvo com variáveis.
+     *
+     * @example
+     * ```ts
+     * const preview = await notifica.templates.preview('tpl_abc', {
+     *   variables: { name: 'João' },
+     * });
+     * ```
+     */
+    preview(id: string, params: PreviewTemplateParams, options?: RequestOptions): Promise<PreviewResult>;
+    /**
+     * Preview de conteúdo arbitrário (útil para editor em tempo real).
+     */
+    previewContent(params: PreviewContentParams, options?: RequestOptions): Promise<PreviewResult>;
+    /**
+     * Valida um template salvo.
+     */
+    validate(id: string, options?: RequestOptions): Promise<ValidationResult>;
+    /**
+     * Valida conteúdo arbitrário.
+     */
+    validateContent(params: ValidateContentParams, options?: RequestOptions): Promise<ValidationResult>;
+}
+
+interface SendStep {
+    type: 'send';
+    channel: Channel;
+    template: string;
+}
+interface DelayStep {
+    type: 'delay';
+    /** Duração no formato "5m", "1h", "1d" */
+    duration: string;
+}
+interface FallbackStep {
+    type: 'fallback';
+    channels: Channel[];
+    template: string;
+}
+type WorkflowStep = SendStep | DelayStep | FallbackStep;
+interface CreateWorkflowParams {
+    /** Identificador URL-safe */
+    slug: string;
+    /** Nome legível */
+    name: string;
+    /** Passos do workflow (max 10) */
+    steps: WorkflowStep[];
+}
+interface UpdateWorkflowParams {
+    name?: string;
+    steps?: WorkflowStep[];
+}
+interface Workflow {
+    id: string;
+    slug: string;
+    name: string;
+    steps: WorkflowStep[];
+    version: number;
+    active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface TriggerWorkflowParams {
+    /** Destinatário (email, telefone, subscriber_id) */
+    recipient: string;
+    /** Variáveis do template */
+    data?: Record<string, unknown>;
+}
+type WorkflowRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+interface WorkflowRun {
+    id: string;
+    workflow_id: string;
+    workflow_slug: string;
+    workflow_version: number;
+    status: WorkflowRunStatus;
+    recipient: string;
+    data?: Record<string, unknown>;
+    step_results?: StepResult[];
+    created_at: string;
+    updated_at: string;
+}
+interface StepResult {
+    step_index: number;
+    step_type: string;
+    status: string;
+    result?: Record<string, unknown>;
+    executed_at: string;
+}
+interface ListWorkflowsParams extends PaginationParams {
+}
+interface ListWorkflowRunsParams extends PaginationParams {
+    /** Filtrar por workflow_id */
+    workflow_id?: string;
+    /** Filtrar por status */
+    status?: WorkflowRunStatus;
+}
+
+declare class Workflows {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Cria um novo workflow.
+     *
+     * @example
+     * ```ts
+     * const workflow = await notifica.workflows.create({
+     *   slug: 'welcome-flow',
+     *   name: 'Fluxo de Boas-Vindas',
+     *   steps: [
+     *     { type: 'send', channel: 'email', template: 'welcome-email' },
+     *     { type: 'delay', duration: '1h' },
+     *     { type: 'send', channel: 'whatsapp', template: 'welcome-whatsapp' },
+     *   ],
+     * });
+     * ```
+     */
+    create(params: CreateWorkflowParams, options?: RequestOptions): Promise<Workflow>;
+    /**
+     * Lista workflows com paginação.
+     */
+    list(params?: ListWorkflowsParams, options?: RequestOptions): Promise<PaginatedResponse<Workflow>>;
+    /**
+     * Itera automaticamente por todos os workflows.
+     */
+    listAll(params?: Omit<ListWorkflowsParams, 'cursor'>): AsyncIterableIterator<Workflow>;
+    /**
+     * Obtém detalhes de um workflow.
+     */
+    get(id: string, options?: RequestOptions): Promise<Workflow>;
+    /**
+     * Atualiza um workflow (cria nova versão).
+     */
+    update(id: string, params: UpdateWorkflowParams, options?: RequestOptions): Promise<Workflow>;
+    /**
+     * Deleta um workflow (soft delete).
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Dispara a execução de um workflow.
+     *
+     * @param slug — Slug do workflow
+     * @param params — Recipient e dados
+     *
+     * @example
+     * ```ts
+     * const run = await notifica.workflows.trigger('welcome-flow', {
+     *   recipient: '+5511999999999',
+     *   data: { name: 'João', plan: 'pro' },
+     * });
+     * ```
+     */
+    trigger(slug: string, params: TriggerWorkflowParams, options?: RequestOptions): Promise<WorkflowRun>;
+    /**
+     * Lista execuções de workflows.
+     */
+    listRuns(params?: ListWorkflowRunsParams, options?: RequestOptions): Promise<PaginatedResponse<WorkflowRun>>;
+    /**
+     * Obtém detalhes de uma execução (incluindo step_results).
+     */
+    getRun(id: string, options?: RequestOptions): Promise<WorkflowRun>;
+    /**
+     * Cancela uma execução em andamento.
+     */
+    cancelRun(id: string, options?: RequestOptions): Promise<WorkflowRun>;
+}
+
+interface CreateSubscriberParams {
+    /** Seu identificador do usuário (upsert key) */
+    external_id: string;
+    /** Email do subscriber */
+    email?: string;
+    /** Telefone E.164 (ex: +5511999998888) */
+    phone?: string;
+    /** Nome de exibição */
+    name?: string;
+    /** Locale preferido */
+    locale?: string;
+    /** Timezone preferida */
+    timezone?: string;
+    /** Dados customizados */
+    custom_properties?: Record<string, unknown>;
+}
+interface UpdateSubscriberParams {
+    email?: string;
+    phone?: string;
+    name?: string;
+    locale?: string;
+    timezone?: string;
+    custom_properties?: Record<string, unknown>;
+}
+interface Subscriber {
+    id: string;
+    external_id: string;
+    email?: string;
+    phone?: string;
+    name?: string;
+    locale?: string;
+    timezone?: string;
+    custom_properties?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface NotificationPreference {
+    category: string;
+    channel: string;
+    enabled: boolean;
+}
+interface UpdatePreferencesParams {
+    preferences: NotificationPreference[];
+}
+interface SubscriberPreferences {
+    preferences: NotificationPreference[];
+}
+interface BulkImportParams {
+    subscribers: CreateSubscriberParams[];
+}
+interface BulkImportResult {
+    imported: number;
+    subscribers: Subscriber[];
+}
+interface InAppNotification {
+    id: string;
+    title?: string;
+    body?: string;
+    action_url?: string;
+    read: boolean;
+    created_at: string;
+}
+interface ListInAppParams {
+    limit?: number;
+    offset?: number;
+    unread_only?: boolean;
+}
+interface UnreadCountResult {
+    count: number;
+}
+interface ListSubscribersParams extends PaginationParams {
+    /** Busca por email, nome ou external_id */
+    search?: string;
+    /** Offset de paginação */
+    offset?: number;
+}
+
+declare class Subscribers {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Cria ou atualiza um subscriber (upsert por external_id).
+     * LGPD: registra consentimento automaticamente.
+     *
+     * @example
+     * ```ts
+     * const subscriber = await notifica.subscribers.create({
+     *   external_id: 'user-123',
+     *   email: 'joao@empresa.com.br',
+     *   phone: '+5511999998888',
+     *   name: 'João Silva',
+     * });
+     * ```
+     */
+    create(params: CreateSubscriberParams, options?: RequestOptions): Promise<Subscriber>;
+    /**
+     * Lista subscribers com paginação.
+     */
+    list(params?: ListSubscribersParams, options?: RequestOptions): Promise<PaginatedResponse<Subscriber>>;
+    /**
+     * Itera automaticamente por todos os subscribers.
+     */
+    listAll(params?: Omit<ListSubscribersParams, 'cursor'>): AsyncIterableIterator<Subscriber>;
+    /**
+     * Obtém detalhes de um subscriber.
+     */
+    get(id: string, options?: RequestOptions): Promise<Subscriber>;
+    /**
+     * Atualiza um subscriber.
+     */
+    update(id: string, params: UpdateSubscriberParams, options?: RequestOptions): Promise<Subscriber>;
+    /**
+     * Deleta um subscriber (soft delete com nullificação de PII — LGPD).
+     * ⚠️ Irreversível: email, telefone e nome são removidos.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Obtém preferências de notificação do subscriber.
+     */
+    getPreferences(id: string, options?: RequestOptions): Promise<SubscriberPreferences>;
+    /**
+     * Atualiza preferências de notificação do subscriber.
+     *
+     * @example
+     * ```ts
+     * await notifica.subscribers.updatePreferences('sub_123', {
+     *   preferences: [
+     *     { category: 'marketing', channel: 'email', enabled: false },
+     *     { category: 'transactional', channel: 'whatsapp', enabled: true },
+     *   ],
+     * });
+     * ```
+     */
+    updatePreferences(id: string, params: UpdatePreferencesParams, options?: RequestOptions): Promise<SubscriberPreferences>;
+    /**
+     * Importa subscribers em lote (upsert transacional).
+     * Se um subscriber falhar validação, todo o lote é revertido.
+     */
+    bulkImport(params: BulkImportParams, options?: RequestOptions): Promise<BulkImportResult>;
+    /**
+     * Lista notificações in-app de um subscriber.
+     */
+    listNotifications(subscriberId: string, params?: ListInAppParams, options?: RequestOptions): Promise<{
+        data: InAppNotification[];
+    }>;
+    /**
+     * Marca uma notificação in-app como lida.
+     */
+    markRead(subscriberId: string, notificationId: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Marca todas as notificações in-app como lidas.
+     */
+    markAllRead(subscriberId: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Obtém contagem de notificações não lidas.
+     */
+    getUnreadCount(subscriberId: string, options?: RequestOptions): Promise<number>;
+}
+
+interface CreateChannelParams {
+    /** Nome do canal */
+    channel: Channel;
+    /** Provider (ex: aws_ses, twilio, meta) */
+    provider: string;
+    /** Credenciais criptografadas */
+    credentials: Record<string, unknown>;
+    /** Configurações (from_address, from_name, etc.) */
+    settings?: Record<string, unknown>;
+}
+interface UpdateChannelParams {
+    provider?: string;
+    credentials?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+}
+interface ChannelConfiguration {
+    id: string;
+    channel: Channel;
+    provider: string;
+    /** Credenciais nunca são retornadas na resposta */
+    settings?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface TestChannelResult {
+    success: boolean;
+    message: string;
+}
+
+declare class Channels {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Configura um canal de notificação.
+     *
+     * @example
+     * ```ts
+     * const channel = await notifica.channels.create({
+     *   channel: 'email',
+     *   provider: 'aws_ses',
+     *   credentials: {
+     *     access_key_id: 'AKIA...',
+     *     secret_access_key: '...',
+     *     region: 'us-east-1',
+     *   },
+     *   settings: {
+     *     from_address: 'noreply@empresa.com.br',
+     *     from_name: 'Empresa',
+     *   },
+     * });
+     * ```
+     */
+    create(params: CreateChannelParams, options?: RequestOptions): Promise<ChannelConfiguration>;
+    /**
+     * Lista todas as configurações de canal.
+     */
+    list(options?: RequestOptions): Promise<ChannelConfiguration[]>;
+    /**
+     * Obtém a configuração de um canal específico.
+     */
+    get(channel: Channel, options?: RequestOptions): Promise<ChannelConfiguration>;
+    /**
+     * Atualiza a configuração de um canal.
+     */
+    update(channel: Channel, params: UpdateChannelParams, options?: RequestOptions): Promise<ChannelConfiguration>;
+    /**
+     * Remove a configuração de um canal.
+     */
+    delete(channel: Channel, options?: RequestOptions): Promise<void>;
+    /**
+     * Envia uma notificação de teste usando a configuração atual do canal.
+     */
+    test(channel: Channel, options?: RequestOptions): Promise<TestChannelResult>;
+}
+
+interface CreateDomainParams {
+    domain: string;
+}
+type DomainStatus = 'pending' | 'verified' | 'failed';
+interface DnsRecord {
+    name: string;
+    type: string;
+    value: string;
+}
+interface Domain {
+    id: string;
+    domain: string;
+    status: DomainStatus;
+    dns_records?: {
+        txt?: DnsRecord;
+        dkim?: DnsRecord[];
+        spf?: DnsRecord;
+    };
+    verified_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface DomainHealth {
+    domain_id: string;
+    dns_valid: boolean;
+    dkim_valid: boolean;
+    spf_valid: boolean;
+    last_checked_at: string;
+    issues?: string[];
+}
+interface DomainAlert {
+    id: string;
+    domain_id: string;
+    alert_type: string;
+    message: string;
+    severity: string;
+    created_at: string;
+}
+interface ListDomainsParams extends PaginationParams {
+}
+
+declare class Domains {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Registra um novo domínio de envio.
+     *
+     * @example
+     * ```ts
+     * const domain = await notifica.domains.create({ domain: 'suaempresa.com.br' });
+     * // Configure os registros DNS retornados em domain.dns_records
+     * ```
+     */
+    create(params: CreateDomainParams, options?: RequestOptions): Promise<Domain>;
+    /**
+     * Lista domínios registrados.
+     */
+    list(params?: ListDomainsParams, options?: RequestOptions): Promise<PaginatedResponse<Domain>>;
+    /**
+     * Obtém detalhes de um domínio.
+     */
+    get(id: string, options?: RequestOptions): Promise<Domain>;
+    /**
+     * Dispara verificação DNS do domínio.
+     */
+    verify(id: string, options?: RequestOptions): Promise<Domain>;
+    /**
+     * Remove um domínio.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Obtém status de saúde do domínio.
+     */
+    getHealth(domainId: string, options?: RequestOptions): Promise<DomainHealth>;
+    /**
+     * Força verificação de saúde (rate limit: 1/min).
+     */
+    checkHealth(domainId: string, options?: RequestOptions): Promise<DomainHealth>;
+    /**
+     * Lista alertas de domínio.
+     */
+    listAlerts(options?: RequestOptions): Promise<DomainAlert[]>;
+}
+
+interface CreateWebhookParams {
+    /** URL de destino */
+    url: string;
+    /** Lista de eventos para escutar */
+    events: string[];
+}
+interface UpdateWebhookParams {
+    url?: string;
+    events?: string[];
+    active?: boolean;
+}
+interface Webhook {
+    id: string;
+    url: string;
+    events: string[];
+    active: boolean;
+    /** Retornado apenas na criação */
+    signing_secret?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface WebhookDelivery {
+    id: string;
+    event: string;
+    status: string;
+    status_code?: number;
+    response_body?: string;
+    created_at: string;
+}
+interface ListWebhooksParams extends PaginationParams {
+}
+interface ListDeliveriesParams {
+    limit?: number;
+}
+
+declare class Webhooks {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Cria um novo webhook.
+     * ⚠️ O signing_secret é retornado apenas na criação. Salve-o!
+     *
+     * @example
+     * ```ts
+     * const webhook = await notifica.webhooks.create({
+     *   url: 'https://meuapp.com.br/webhooks/notifica',
+     *   events: ['notification.delivered', 'notification.failed'],
+     * });
+     * // Salve: webhook.signing_secret
+     * ```
+     */
+    create(params: CreateWebhookParams, options?: RequestOptions): Promise<Webhook>;
+    /**
+     * Lista webhooks com paginação.
+     */
+    list(params?: ListWebhooksParams, options?: RequestOptions): Promise<PaginatedResponse<Webhook>>;
+    /**
+     * Obtém detalhes de um webhook.
+     */
+    get(id: string, options?: RequestOptions): Promise<Webhook>;
+    /**
+     * Atualiza um webhook.
+     */
+    update(id: string, params: UpdateWebhookParams, options?: RequestOptions): Promise<Webhook>;
+    /**
+     * Deleta um webhook.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Envia um evento de teste para o webhook.
+     */
+    test(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Lista entregas recentes de um webhook.
+     */
+    listDeliveries(id: string, params?: ListDeliveriesParams, options?: RequestOptions): Promise<WebhookDelivery[]>;
+    /**
+     * Verifica a assinatura HMAC de um payload de webhook.
+     *
+     * Use para validar que o payload foi realmente enviado pelo Notifica.
+     *
+     * @param payload — Body da request (string ou Buffer)
+     * @param signature — Valor do header `X-Notifica-Signature`
+     * @param secret — signing_secret do webhook
+     * @returns true se a assinatura é válida
+     *
+     * @example
+     * ```ts
+     * app.post('/webhooks/notifica', (req, res) => {
+     *   const payload = req.body; // raw body string
+     *   const signature = req.headers['x-notifica-signature'];
+     *   const secret = process.env.WEBHOOK_SECRET;
+     *
+     *   if (!notifica.webhooks.verify(payload, signature, secret)) {
+     *     return res.status(401).send('Invalid signature');
+     *   }
+     *
+     *   // Processar evento...
+     *   res.status(200).send('OK');
+     * });
+     * ```
+     */
+    verify(payload: string | ArrayBuffer | Uint8Array, signature: string, secret: string): Promise<boolean>;
+    /**
+     * Verifica a assinatura e lança erro se inválida.
+     * Versão "fail-fast" do verify().
+     */
+    verifyOrThrow(payload: string | ArrayBuffer | Uint8Array, signature: string, secret: string): Promise<void>;
+    private toHex;
+    /**
+     * Constant-time string comparison to prevent timing attacks.
+     */
+    private timingSafeEqual;
+}
+
+interface CreateApiKeyParams {
+    key_type: ApiKeyType;
+    label: string;
+    environment: Environment;
+}
+interface ApiKey {
+    id: string;
+    key_type: ApiKeyType;
+    label: string;
+    prefix: string;
+    environment: Environment;
+    /** Retornado apenas na criação */
+    raw_key?: string;
+    created_at: string;
+}
+
+declare class ApiKeys {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Cria uma nova API key.
+     * ⚠️ O raw_key é retornado apenas na criação. Salve-o!
+     *
+     * @example
+     * ```ts
+     * const key = await notifica.apiKeys.create({
+     *   key_type: 'secret',
+     *   label: 'Backend Production',
+     *   environment: 'production',
+     * });
+     * // Salve: key.raw_key
+     * ```
+     */
+    create(params: CreateApiKeyParams, options?: RequestOptions): Promise<ApiKey>;
+    /**
+     * Lista API keys (sem raw_key).
+     */
+    list(options?: RequestOptions): Promise<ApiKey[]>;
+    /**
+     * Revoga (deleta) uma API key.
+     */
+    revoke(id: string, options?: RequestOptions): Promise<void>;
+}
+
+type AnalyticsPeriod = '1h' | '24h' | '7d' | '30d';
+type Granularity = 'hour' | 'day';
+interface AnalyticsParams {
+    period?: AnalyticsPeriod;
+}
+interface TimeseriesParams extends AnalyticsParams {
+    granularity?: Granularity;
+}
+interface TopTemplatesParams extends AnalyticsParams {
+    limit?: number;
+}
+interface AnalyticsOverview {
+    total_sent: number;
+    total_delivered: number;
+    total_failed: number;
+    delivery_rate: number;
+    period: AnalyticsPeriod;
+}
+interface ChannelAnalytics {
+    channel: string;
+    sent: number;
+    delivered: number;
+    failed: number;
+    delivery_rate: number;
+}
+interface TimeseriesPoint {
+    timestamp: string;
+    sent: number;
+    delivered: number;
+    failed: number;
+}
+interface TemplateAnalytics {
+    template_id: string;
+    template_name: string;
+    sent: number;
+    delivered: number;
+    delivery_rate: number;
+}
+
+declare class Analytics {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Métricas gerais (total enviado, entregue, falhas, taxa de entrega).
+     *
+     * @example
+     * ```ts
+     * const overview = await notifica.analytics.overview({ period: '7d' });
+     * console.log(`Taxa de entrega: ${overview.delivery_rate}%`);
+     * ```
+     */
+    overview(params?: AnalyticsParams, options?: RequestOptions): Promise<AnalyticsOverview>;
+    /**
+     * Métricas por canal.
+     */
+    byChannel(params?: AnalyticsParams, options?: RequestOptions): Promise<ChannelAnalytics[]>;
+    /**
+     * Série temporal de envios.
+     */
+    timeseries(params?: TimeseriesParams, options?: RequestOptions): Promise<TimeseriesPoint[]>;
+    /**
+     * Templates mais utilizados.
+     */
+    topTemplates(params?: TopTemplatesParams, options?: RequestOptions): Promise<TemplateAnalytics[]>;
+}
+
+type SmsProviderType = 'twilio' | 'zenvia' | 'custom';
+interface TwilioConfig {
+    /** Account SID da Twilio */
+    account_sid: string;
+    /** Auth Token da Twilio */
+    auth_token: string;
+    /** Número de telefone Twilio (E.164) */
+    phone_number: string;
+    /** SID do Messaging Service (opcional) */
+    messaging_service_sid?: string;
+}
+interface ZenviaConfig {
+    /** API Key da Zenvia */
+    api_key: string;
+    /** Nome do remetente (ex: sua empresa) */
+    from: string;
+}
+interface CustomSmsConfig {
+    /** URL do webhook para envio de SMS */
+    webhook_url: string;
+    /** Headers customizados para o webhook */
+    headers?: Record<string, string>;
+    /** Timeout em ms (default: 30000) */
+    timeout?: number;
+}
+interface SmsProviderConfig {
+    type: SmsProviderType;
+    /** Nome identificador do provedor */
+    name: string;
+    /** Configuração específica do provedor */
+    config: TwilioConfig | ZenviaConfig | CustomSmsConfig;
+    /** Se o provedor está ativo */
+    active?: boolean;
+    /** Regiões permitidas (códigos ISO 3166-1 alpha-2) */
+    allowed_regions?: string[];
+    /** Limite de rate limit por minuto */
+    rate_limit_per_minute?: number;
+}
+interface SmsProvider {
+    id: string;
+    type: SmsProviderType;
+    name: string;
+    /** Configuração mascarada (credenciais parciais) */
+    config_mask?: string;
+    active: boolean;
+    is_default: boolean;
+    allowed_regions: string[] | null;
+    rate_limit_per_minute: number | null;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateSmsProviderParams {
+    type: SmsProviderType;
+    name: string;
+    config: TwilioConfig | ZenviaConfig | CustomSmsConfig;
+    active?: boolean;
+    allowed_regions?: string[];
+    rate_limit_per_minute?: number;
+}
+interface UpdateSmsProviderParams {
+    name?: string;
+    config?: TwilioConfig | ZenviaConfig | CustomSmsConfig;
+    active?: boolean;
+    allowed_regions?: string[];
+    rate_limit_per_minute?: number;
+}
+interface ValidateSmsProviderParams {
+    type: SmsProviderType;
+    config: TwilioConfig | ZenviaConfig | CustomSmsConfig;
+}
+interface ValidateSmsProviderResult {
+    valid: boolean;
+    message?: string;
+    errors?: Record<string, string[]>;
+}
+interface TestSmsProviderParams {
+    /** ID do provedor (para provedores já criados) */
+    provider_id?: string;
+    /** Configuração para teste (para validar antes de criar) */
+    config?: SmsProviderConfig;
+    /** Número de telefone de destino para teste (E.164) */
+    to: string;
+    /** Mensagem de teste (opcional) */
+    message?: string;
+}
+interface TestSmsProviderResult {
+    success: boolean;
+    message: string;
+    message_id?: string;
+}
+interface SmsComplianceSettings {
+    /** Horário comercial permitido (formato HH:MM) */
+    allowed_hours_start: string | null;
+    /** Horário comercial permitido (formato HH:MM) */
+    allowed_hours_end: string | null;
+    /** Dias da semana permitidos (0=Domingo, 6=Sábado) */
+    allowed_weekdays: number[] | null;
+    /** Feriados nacionais brasileiros são respeitados automaticamente */
+    respect_national_holidays: boolean;
+    /** Feriados adicionais (formato MM-DD) */
+    custom_holidays: string[] | null;
+    /** Mensagem padrão de opt-out */
+    opt_out_message: string | null;
+    /** Palavras-chave para opt-out (ex: "SAIR, CANCELAR") */
+    opt_out_keywords: string[] | null;
+    /** Horas de quarentena após opt-out */
+    opt_out_cooldown_hours: number | null;
+    /** Mensagem de confirmação de opt-in */
+    opt_in_confirmation_message: string | null;
+}
+interface UpdateSmsComplianceParams {
+    allowed_hours_start?: string;
+    allowed_hours_end?: string;
+    allowed_weekdays?: number[];
+    respect_national_holidays?: boolean;
+    custom_holidays?: string[];
+    opt_out_message?: string;
+    opt_out_keywords?: string[];
+    opt_out_cooldown_hours?: number;
+    opt_in_confirmation_message?: string;
+}
+interface SmsComplianceAnalytics {
+    period_start: string;
+    period_end: string;
+    total_messages: number;
+    messages_blocked_by_compliance: number;
+    opt_outs_received: number;
+    opt_ins_received: number;
+    violations_by_type: Record<string, number>;
+}
+interface SmsComplianceLog {
+    id: string;
+    message_id: string;
+    phone: string;
+    action: 'blocked' | 'allowed' | 'opt_out' | 'opt_in';
+    reason?: string;
+    created_at: string;
+}
+interface ListComplianceLogsParams extends PaginationParams {
+    phone?: string;
+    action?: 'blocked' | 'allowed' | 'opt_out' | 'opt_in';
+    start_date?: string;
+    end_date?: string;
+}
+type SmsConsentStatus = 'opted_in' | 'opted_out' | 'pending';
+type SmsConsentSource = 'manual' | 'import' | 'api' | 'webhook' | 'opt_out_reply' | 'opt_in_reply';
+interface SmsConsent {
+    phone: string;
+    status: SmsConsentStatus;
+    source: SmsConsentSource;
+    metadata?: Record<string, unknown>;
+    opted_in_at: string | null;
+    opted_out_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateSmsConsentParams {
+    phone: string;
+    status?: SmsConsentStatus;
+    source?: SmsConsentSource;
+    metadata?: Record<string, unknown>;
+}
+interface BulkImportSmsConsentParams {
+    consents: CreateSmsConsentParams[];
+}
+interface BulkImportSmsConsentResult {
+    imported: number;
+    errors?: Array<{
+        phone: string;
+        error: string;
+    }>;
+}
+interface SmsConsentSummary {
+    total: number;
+    opted_in: number;
+    opted_out: number;
+    pending: number;
+    by_source: Record<SmsConsentSource, number>;
+}
+interface ListSmsConsentsParams extends PaginationParams {
+    phone?: string;
+    status?: SmsConsentStatus;
+    source?: SmsConsentSource;
+}
+
+declare class SmsProviders {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Lista todos os provedores SMS configurados.
+     */
+    list(options?: RequestOptions): Promise<SmsProvider[]>;
+    /**
+     * Cria um novo provedor SMS (idempotent).
+     */
+    create(params: CreateSmsProviderParams, options?: RequestOptions): Promise<SmsProvider>;
+    /**
+     * Obtém detalhes de um provedor SMS.
+     */
+    get(id: string, options?: RequestOptions): Promise<SmsProvider>;
+    /**
+     * Atualiza um provedor SMS (PATCH parcial).
+     */
+    update(id: string, params: UpdateSmsProviderParams, options?: RequestOptions): Promise<SmsProvider>;
+    /**
+     * Ativa um provedor SMS.
+     */
+    activate(id: string, options?: RequestOptions): Promise<SmsProvider>;
+    /**
+     * Remove um provedor SMS.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Valida a configuração de um provedor SMS.
+     */
+    validate(params: ValidateSmsProviderParams, options?: RequestOptions): Promise<ValidateSmsProviderResult>;
+    /**
+     * Envia um SMS de teste.
+     */
+    test(params: TestSmsProviderParams, options?: RequestOptions): Promise<TestSmsProviderResult>;
+}
+declare class SmsCompliance {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Obtém as configurações de compliance SMS.
+     */
+    show(options?: RequestOptions): Promise<SmsComplianceSettings>;
+    /**
+     * Atualiza as configurações de compliance SMS (PATCH parcial).
+     */
+    update(params: UpdateSmsComplianceParams, options?: RequestOptions): Promise<SmsComplianceSettings>;
+    /**
+     * Obtém estatísticas de compliance.
+     */
+    analytics(options?: RequestOptions): Promise<SmsComplianceAnalytics>;
+    /**
+     * Lista logs de compliance com paginação.
+     */
+    logs(params?: ListComplianceLogsParams, options?: RequestOptions): Promise<PaginatedResponse<SmsComplianceLog>>;
+}
+declare class SmsConsents {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Lista consentimentos SMS com paginação.
+     */
+    list(params?: ListSmsConsentsParams, options?: RequestOptions): Promise<PaginatedResponse<SmsConsent>>;
+    /**
+     * Obtém resumo estatístico dos consentimentos.
+     */
+    summary(options?: RequestOptions): Promise<SmsConsentSummary>;
+    /**
+     * Obtém o consentimento de um número específico.
+     */
+    get(phone: string, options?: RequestOptions): Promise<SmsConsent>;
+    /**
+     * Revoga o consentimento de um número (DELETE).
+     */
+    revoke(phone: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Cria ou atualiza um consentimento SMS (idempotent).
+     */
+    create(params: CreateSmsConsentParams, options?: RequestOptions): Promise<SmsConsent>;
+    /**
+     * Importa consentimentos em lote.
+     */
+    import(params: BulkImportSmsConsentParams, options?: RequestOptions): Promise<BulkImportSmsConsentResult>;
+}
+declare class Sms {
+    readonly providers: SmsProviders;
+    readonly compliance: SmsCompliance;
+    readonly consents: SmsConsents;
+    constructor(client: NotificaClient);
+}
+
+interface BillingPlan {
+    /** Identificador único do plano */
+    name: string;
+    /** Nome de exibição */
+    display_name: string;
+    /** Descrição do plano */
+    description: string | null;
+    /** Preço mensal em centavos */
+    monthly_price_cents: number;
+    /** Preço anual em centavos (com desconto) */
+    yearly_price_cents: number;
+    /** Período de trial em dias */
+    trial_days: number;
+    /** Quotas incluídas no plano */
+    quotas: BillingQuotas;
+    /** Recursos habilitados */
+    features: BillingFeatures;
+    /** Se o plano está disponível para novas assinaturas */
+    available: boolean;
+    /** Ordem de exibição */
+    sort_order: number;
+}
+interface BillingQuotas {
+    /** Limite de notificações por mês (null = ilimitado) */
+    notifications_per_month: number | null;
+    /** Limite de emails por mês */
+    emails_per_month: number | null;
+    /** Limite de SMS por mês */
+    sms_per_month: number | null;
+    /** Limite de WhatsApp por mês */
+    whatsapp_per_month: number | null;
+    /** Limite de subscribers */
+    subscribers_limit: number | null;
+    /** Limite de templates */
+    templates_limit: number | null;
+    /** Limite de workflows */
+    workflows_limit: number | null;
+    /** Limite de usuários do tenant */
+    team_members_limit: number | null;
+}
+interface BillingFeatures {
+    /** Suporte a múltiplos canais */
+    multi_channel: boolean;
+    /** Workflows avançados */
+    advanced_workflows: boolean;
+    /** Webhooks personalizados */
+    custom_webhooks: boolean;
+    /** API dedicada */
+    dedicated_api: boolean;
+    /** Suporte prioritário */
+    priority_support: boolean;
+    /** SLA garantido */
+    sla_guarantee: boolean;
+    /** LGPD compliance avançado */
+    advanced_lgpd: boolean;
+    /** SSO/SAML */
+    sso: boolean;
+    /** Logs de auditoria */
+    audit_logs: boolean;
+}
+type BillingGatewayType = 'asaas' | 'efi';
+interface BillingSettings {
+    /** Gateway de pagamento configurado */
+    gateway: BillingGatewayType | null;
+    /** Moeda (default: BRL) */
+    currency: string;
+    /** Fuso horário para faturamento */
+    timezone: string;
+    /** Dia de vencimento (1-31) */
+    due_day: number | null;
+    /** Informações fiscais */
+    tax_info: BillingTaxInfo | null;
+}
+interface BillingTaxInfo {
+    /** Tipo de pessoa: física ou jurídica */
+    person_type: 'individual' | 'company';
+    /** CPF ou CNPJ */
+    document: string;
+    /** Razão social ou nome completo */
+    legal_name: string;
+    /** Email para faturas */
+    billing_email: string;
+    /** Endereço */
+    address?: BillingAddress;
+}
+interface BillingAddress {
+    street: string;
+    number: string;
+    complement?: string;
+    neighborhood: string;
+    city: string;
+    state: string;
+    zip_code: string;
+    country: string;
+}
+type SubscriptionStatus = 'trial' | 'active' | 'past_due' | 'canceled' | 'paused' | 'expired';
+type SubscriptionPeriod = 'monthly' | 'yearly';
+interface Subscription {
+    id: string;
+    plan_name: string;
+    status: SubscriptionStatus;
+    period: SubscriptionPeriod;
+    /** Data de início da assinatura */
+    starts_at: string;
+    /** Próxima data de cobrança */
+    current_period_ends_at: string;
+    /** Data de término (se cancelada) */
+    ends_at: string | null;
+    /** Dias restantes de trial */
+    trial_days_remaining: number | null;
+    /** Se está em trial */
+    in_trial: boolean;
+    /** Se será renovada automaticamente */
+    auto_renew: boolean;
+    /** Valor atual em centavos */
+    current_price_cents: number;
+    created_at: string;
+    updated_at: string;
+}
+interface SubscribeParams {
+    plan_name: string;
+    period?: SubscriptionPeriod;
+    payment_method_id?: string;
+    /** Código de cupom (opcional) */
+    coupon_code?: string;
+}
+interface ChangePlanParams {
+    plan_name: string;
+    period?: SubscriptionPeriod;
+    /** Efetivar imediatamente ou no próximo ciclo */
+    effective_immediately?: boolean;
+}
+interface CancelSubscriptionParams {
+    /** Efetivar no fim do período atual */
+    at_period_end?: boolean;
+    /** Motivo do cancelamento */
+    reason?: string;
+}
+interface ReactivateSubscriptionParams {
+    payment_method_id?: string;
+}
+interface CalculateProrationParams {
+    plan_name: string;
+    period?: SubscriptionPeriod;
+}
+interface CalculateProrationResult {
+    /** Crédito do plano atual */
+    current_plan_credit_cents: number;
+    /** Débito do novo plano */
+    new_plan_debit_cents: number;
+    /** Valor a pagar (pode ser negativo = crédito) */
+    proration_amount_cents: number;
+    /** Nova data de vencimento */
+    next_billing_date: string;
+}
+interface BillingUsage {
+    /** Período atual */
+    period_start: string;
+    period_end: string;
+    /** Uso atual */
+    current: BillingUsageMetrics;
+    /** Quotas do plano */
+    quotas: BillingQuotas;
+    /** Percentuais de uso (0-100, null = ilimitado) */
+    percentages: BillingUsagePercentages;
+}
+interface BillingUsageMetrics {
+    notifications: number;
+    emails: number;
+    sms: number;
+    whatsapp: number;
+    subscribers: number;
+    templates: number;
+    workflows: number;
+    team_members: number;
+}
+interface BillingUsagePercentages {
+    notifications: number | null;
+    emails: number | null;
+    sms: number | null;
+    whatsapp: number | null;
+    subscribers: number | null;
+    templates: number | null;
+    workflows: number | null;
+    team_members: number | null;
+}
+type InvoiceStatus = 'pending' | 'paid' | 'overdue' | 'canceled' | 'refunded' | 'processing';
+type PaymentMethodType = 'credit_card' | 'pix' | 'boleto';
+interface Invoice {
+    id: string;
+    subscription_id: string;
+    status: InvoiceStatus;
+    /** Valor em centavos */
+    amount_cents: number;
+    /** Valor pago em centavos */
+    amount_paid_cents: number;
+    currency: string;
+    /** Descrição da fatura */
+    description: string;
+    /** Método de pagamento utilizado */
+    payment_method: PaymentMethodType | null;
+    /** Data de vencimento */
+    due_date: string;
+    /** Data de pagamento */
+    paid_at: string | null;
+    /** URL do boleto (se aplicável) */
+    boleto_url: string | null;
+    /** Código PIX (se aplicável) */
+    pix_code: string | null;
+    /** QR Code PIX (base64) */
+    pix_qr_code: string | null;
+    /** Linha digitável do boleto */
+    boleto_line: string | null;
+    /** PDF do boleto */
+    boleto_pdf_url: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface ListInvoicesParams extends PaginationParams {
+    status?: InvoiceStatus;
+    start_date?: string;
+    end_date?: string;
+}
+type CardBrand = 'visa' | 'mastercard' | 'amex' | 'elo' | 'hipercard' | 'diners' | 'discover' | 'jcb' | 'aura' | 'unknown';
+interface PaymentMethodCard {
+    brand: CardBrand;
+    last_four: string;
+    exp_month: number;
+    exp_year: number;
+    holder_name: string;
+}
+interface PaymentMethod {
+    id: string;
+    type: PaymentMethodType;
+    /** Se é o método padrão */
+    is_default: boolean;
+    /** Dados do cartão (se type = credit_card) */
+    card: PaymentMethodCard | null;
+    /** Chave PIX (se type = pix) */
+    pix_key: string | null;
+    /** Tipo de chave PIX */
+    pix_key_type: 'cpf' | 'cnpj' | 'email' | 'phone' | 'random' | null;
+    /** Apelido do método */
+    nickname: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface CreatePaymentMethodParams {
+    type: PaymentMethodType;
+    /** Token do cartão (do gateway de pagamento) */
+    card_token?: string;
+    /** Dados do cartão para tokenização */
+    card?: CreateCardParams;
+    /** Chave PIX */
+    pix_key?: string;
+    pix_key_type?: 'cpf' | 'cnpj' | 'email' | 'phone' | 'random';
+    /** Apelido identificador */
+    nickname?: string;
+    /** Definir como padrão */
+    set_as_default?: boolean;
+}
+interface CreateCardParams {
+    number: string;
+    holder_name: string;
+    exp_month: number;
+    exp_year: number;
+    cvv: string;
+}
+interface UpdatePaymentMethodParams {
+    nickname?: string;
+    /** Apenas para cartões - atualizar dados */
+    exp_month?: number;
+    exp_year?: number;
+}
+
+declare class BillingPlans {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Lista todos os planos disponíveis.
+     */
+    list(options?: RequestOptions): Promise<BillingPlan[]>;
+    /**
+     * Obtém detalhes de um plano específico.
+     */
+    get(name: string, options?: RequestOptions): Promise<BillingPlan>;
+}
+declare class BillingSettingsResource {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Obtém as configurações de faturamento do tenant.
+     */
+    get(options?: RequestOptions): Promise<BillingSettings>;
+}
+declare class BillingSubscription {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Obtém a assinatura atual.
+     */
+    get(options?: RequestOptions): Promise<Subscription>;
+    /**
+     * Cria uma nova assinatura (idempotent).
+     */
+    subscribe(params: SubscribeParams, options?: RequestOptions): Promise<Subscription>;
+    /**
+     * Altera o plano da assinatura (idempotent).
+     */
+    changePlan(params: ChangePlanParams, options?: RequestOptions): Promise<Subscription>;
+    /**
+     * Cancela a assinatura (idempotent).
+     */
+    cancel(params?: CancelSubscriptionParams, options?: RequestOptions): Promise<Subscription>;
+    /**
+     * Calcula o valor de proration para mudança de plano.
+     */
+    calculateProration(params: CalculateProrationParams, options?: RequestOptions): Promise<CalculateProrationResult>;
+    /**
+     * Reativa uma assinatura cancelada (idempotent).
+     */
+    reactivate(params?: ReactivateSubscriptionParams, options?: RequestOptions): Promise<Subscription>;
+}
+declare class BillingUsageResource {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Obtém o uso atual e quotas do tenant.
+     */
+    get(options?: RequestOptions): Promise<BillingUsage>;
+}
+declare class BillingInvoices {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Lista faturas com paginação.
+     */
+    list(params?: ListInvoicesParams, options?: RequestOptions): Promise<PaginatedResponse<Invoice>>;
+    /**
+     * Obtém detalhes de uma fatura.
+     */
+    get(id: string, options?: RequestOptions): Promise<Invoice>;
+}
+declare class BillingPaymentMethods {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Lista métodos de pagamento.
+     */
+    list(options?: RequestOptions): Promise<PaymentMethod[]>;
+    /**
+     * Cria um novo método de pagamento (idempotent).
+     */
+    create(params: CreatePaymentMethodParams, options?: RequestOptions): Promise<PaymentMethod>;
+    /**
+     * Obtém detalhes de um método de pagamento.
+     */
+    get(id: string, options?: RequestOptions): Promise<PaymentMethod>;
+    /**
+     * Atualiza um método de pagamento.
+     */
+    update(id: string, params: UpdatePaymentMethodParams, options?: RequestOptions): Promise<PaymentMethod>;
+    /**
+     * Remove um método de pagamento.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Define um método de pagamento como padrão.
+     */
+    setDefault(id: string, options?: RequestOptions): Promise<PaymentMethod>;
+}
+declare class Billing {
+    readonly plans: BillingPlans;
+    readonly settings: BillingSettingsResource;
+    readonly subscription: BillingSubscription;
+    readonly usage: BillingUsageResource;
+    readonly invoices: BillingInvoices;
+    readonly paymentMethods: BillingPaymentMethods;
+    constructor(client: NotificaClient);
+}
+
+interface InboxEmbedSettings {
+    /** Se o inbox embed está habilitado */
+    enabled: boolean;
+    /** Tema: 'light', 'dark', ou 'auto' */
+    theme: 'light' | 'dark' | 'auto';
+    /** Posição do widget: 'bottom-right', 'bottom-left', 'top-right', 'top-left' */
+    position: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Título do widget */
+    title: string | null;
+    /** Cor primária (hex) */
+    primary_color: string | null;
+    /** Cor de fundo (hex) */
+    background_color: string | null;
+    /** Texto do botão quando há notificações não lidas */
+    unread_badge_text: string | null;
+    /** Mostrar avatar do remetente */
+    show_sender_avatar: boolean;
+    /** Mostrar timestamp */
+    show_timestamp: boolean;
+    /** Formato de data */
+    date_format: 'relative' | 'absolute' | 'both';
+    /** Máximo de notificações exibidas */
+    max_notifications: number;
+    /** Texto quando não há notificações */
+    empty_state_text: string | null;
+    /** URL do logo customizado */
+    custom_logo_url: string | null;
+    /** CSS customizado */
+    custom_css: string | null;
+    /** Chave de embed para uso no frontend (pk_...) */
+    embed_key: string;
+    /** Domínios permitidos (CORS) */
+    allowed_domains: string[];
+    created_at: string;
+    updated_at: string;
+}
+interface UpdateInboxEmbedSettingsParams {
+    enabled?: boolean;
+    theme?: 'light' | 'dark' | 'auto';
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    title?: string;
+    primary_color?: string;
+    background_color?: string;
+    unread_badge_text?: string;
+    show_sender_avatar?: boolean;
+    show_timestamp?: boolean;
+    date_format?: 'relative' | 'absolute' | 'both';
+    max_notifications?: number;
+    empty_state_text?: string;
+    custom_logo_url?: string;
+    custom_css?: string;
+    allowed_domains?: string[];
+}
+interface RotateEmbedKeyResult {
+    /** Nova chave de embed gerada */
+    embed_key: string;
+    /** Data de expiração da chave antiga (grace period) */
+    old_key_expires_at: string;
+}
+
+declare class InboxEmbed {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Obtém as configurações do inbox embed.
+     */
+    getSettings(options?: RequestOptions): Promise<InboxEmbedSettings>;
+    /**
+     * Atualiza as configurações do inbox embed.
+     */
+    updateSettings(params: UpdateInboxEmbedSettingsParams, options?: RequestOptions): Promise<InboxEmbedSettings>;
+    /**
+     * Rotaciona a chave de embed.
+     * A chave antiga continua funcionando por um período de grace period.
+     */
+    rotateKey(options?: RequestOptions): Promise<RotateEmbedKeyResult>;
+}
+
+/** Notificação do inbox público (similar ao InAppNotification de subscribers) */
+interface InboxNotification {
+    id: string;
+    /** Título da notificação */
+    title: string | null;
+    /** Corpo/conteúdo */
+    body: string | null;
+    /** URL para ação */
+    action_url: string | null;
+    /** Se já foi lida */
+    read: boolean;
+    /** Ícone/imagem (URL) */
+    image_url: string | null;
+    /** Categoria/tipo */
+    category: string | null;
+    /** Metadados customizados */
+    metadata: Record<string, unknown> | null;
+    /** Data de envio */
+    sent_at: string;
+    /** Data de criação */
+    created_at: string;
+}
+interface ListInboxNotificationsParams extends PaginationParams {
+    /** Filtrar apenas não lidas */
+    unread_only?: boolean;
+    /** Categoria específica */
+    category?: string;
+    /** Data de início (ISO 8601) */
+    start_date?: string;
+    /** Data de fim (ISO 8601) */
+    end_date?: string;
+}
+interface InboxUnreadCountResult {
+    count: number;
+}
+interface MarkInboxReadResult {
+    success: boolean;
+    notification_id?: string;
+}
+interface MarkInboxReadAllResult {
+    success: boolean;
+    marked_count: number;
+}
+
+/**
+ * Inbox público — usa publishable key (pk_*).
+ * Este recurso permite consultar notificações usando a chave pública,
+ * ideal para integração direta no frontend.
+ */
+declare class Inbox {
+    private readonly client;
+    constructor(client: NotificaClient);
+    /**
+     * Lista notificações do inbox.
+     * Requer subscriber_id ou external_id como parâmetro de query.
+     */
+    listNotifications(subscriberId: string, params?: Omit<ListInboxNotificationsParams, 'subscriber_id'>, options?: RequestOptions): Promise<PaginatedResponse<InboxNotification>>;
+    /**
+     * Obtém a contagem de notificações não lidas.
+     */
+    getUnreadCount(subscriberId: string, options?: RequestOptions): Promise<number>;
+    /**
+     * Marca uma notificação como lida.
+     */
+    markRead(notificationId: string, options?: RequestOptions): Promise<MarkInboxReadResult>;
+    /**
+     * Marca todas as notificações como lidas.
+     * Requer subscriber_id como parâmetro de query.
+     */
+    markAllRead(subscriberId: string, options?: RequestOptions): Promise<MarkInboxReadAllResult>;
+}
+
+/**
+ * Classe base para todos os erros do SDK Notifica.
+ */
+declare class NotificaError extends Error {
+    constructor(message: string);
+}
+/**
+ * Erro retornado pela API.
+ * Contém status HTTP, código do erro, e request ID para debugging.
+ */
+declare class ApiError extends NotificaError {
+    /** HTTP status code */
+    readonly status: number;
+    /** Código do erro retornado pela API (ex: "validation_failed") */
+    readonly code: string;
+    /** Detalhes de validação por campo */
+    readonly details: Record<string, string[]>;
+    /** ID da request para suporte/debugging */
+    readonly requestId: string | null;
+    constructor(message: string, status: number, code: string, details?: Record<string, string[]>, requestId?: string | null);
+}
+/**
+ * Erro de validação (HTTP 422).
+ */
+declare class ValidationError extends ApiError {
+    constructor(message: string, details?: Record<string, string[]>, requestId?: string | null);
+}
+/**
+ * Rate limit excedido (HTTP 429).
+ * Inclui o tempo para tentar novamente.
+ */
+declare class RateLimitError extends ApiError {
+    /** Segundos até poder tentar novamente */
+    readonly retryAfter: number | null;
+    constructor(message: string, retryAfter?: number | null, requestId?: string | null);
+}
+/**
+ * Timeout de conexão ou request.
+ */
+declare class TimeoutError extends NotificaError {
+    constructor(timeoutMs: number);
+}
+
+/**
+ * Cliente oficial do Notifica para Node.js.
+ *
+ * @example
+ * ```ts
+ * import { Notifica } from '@notifica/node';
+ *
+ * const notifica = new Notifica('nk_live_...');
+ *
+ * // Enviar notificação
+ * await notifica.notifications.send({
+ *   channel: 'whatsapp',
+ *   to: '+5511999999999',
+ *   template: 'welcome',
+ *   data: { name: 'João' },
+ * });
+ *
+ * // Disparar workflow
+ * await notifica.workflows.trigger('welcome-flow', {
+ *   recipient: '+5511999999999',
+ *   data: { name: 'João' },
+ * });
+ * ```
+ */
+declare class Notifica {
+    readonly notifications: Notifications;
+    readonly templates: Templates;
+    readonly workflows: Workflows;
+    readonly subscribers: Subscribers;
+    readonly channels: Channels;
+    readonly domains: Domains;
+    readonly webhooks: Webhooks;
+    readonly apiKeys: ApiKeys;
+    readonly analytics: Analytics;
+    readonly sms: Sms;
+    readonly billing: Billing;
+    readonly inboxEmbed: InboxEmbed;
+    readonly inbox: Inbox;
+    /**
+     * Cria uma nova instância do cliente Notifica.
+     *
+     * @param apiKeyOrConfig — API key (string) ou objeto de configuração completo
+     *
+     * @example
+     * ```ts
+     * // Simples — apenas API key
+     * const notifica = new Notifica('nk_live_...');
+     *
+     * // Configuração completa
+     * const notifica = new Notifica({
+     *   apiKey: 'nk_live_...',
+     *   baseUrl: 'https://app.usenotifica.com.br/v1',
+     *   timeout: 15000,
+     *   maxRetries: 5,
+     * });
+     * ```
+     */
+    constructor(apiKeyOrConfig: string | NotificaClientConfig);
+}
+
+export { Analytics, type AnalyticsOverview, type AnalyticsParams, type AnalyticsPeriod, ApiError, type ApiErrorBody, type ApiKey, type ApiKeyType, ApiKeys, Billing, type BillingAddress, type BillingFeatures, type BillingGatewayType, type BillingPlan, type BillingQuotas, type BillingSettings, type BillingTaxInfo, type BillingUsage, type BillingUsageMetrics, type BillingUsagePercentages, type BulkImportParams, type BulkImportResult, type BulkImportSmsConsentParams, type BulkImportSmsConsentResult, type CalculateProrationParams, type CalculateProrationResult, type CancelSubscriptionParams, type CardBrand, type ChangePlanParams, type Channel, type ChannelAnalytics, type ChannelConfiguration, Channels, type CreateApiKeyParams, type CreateCardParams, type CreateChannelParams, type CreateDomainParams, type CreatePaymentMethodParams, type CreateSmsConsentParams, type CreateSmsProviderParams, type CreateSubscriberParams, type CreateTemplateParams, type CreateWebhookParams, type CreateWorkflowParams, type CustomSmsConfig, type DelayStep, type DnsRecord, type Domain, type DomainAlert, type DomainHealth, type DomainStatus, Domains, type Environment, type FallbackStep, type Granularity, type InAppNotification, Inbox, InboxEmbed, type InboxEmbedSettings, type InboxNotification, type InboxUnreadCountResult, type Invoice, type InvoiceStatus, type ListComplianceLogsParams, type ListDeliveriesParams, type ListDomainsParams, type ListInAppParams, type ListInboxNotificationsParams, type ListInvoicesParams, type ListNotificationsParams, type ListSmsConsentsParams, type ListSubscribersParams, type ListTemplatesParams, type ListWebhooksParams, type ListWorkflowRunsParams, type ListWorkflowsParams, type MarkInboxReadAllResult, type MarkInboxReadResult, type MessageAttempt, Notifica, NotificaClient, type NotificaClientConfig, NotificaError, type Notification, type NotificationPreference, type NotificationStatus, Notifications, type PaginatedResponse, type PaginationMeta, type PaginationParams, type PaymentMethod, type PaymentMethodCard, type PaymentMethodType, type PreviewContentParams, type PreviewResult, type PreviewTemplateParams, RateLimitError, type ReactivateSubscriptionParams, type RequestOptions, type RotateEmbedKeyResult, type SendNotificationParams, type SendStep, type SingleResponse, Sms, type SmsComplianceAnalytics, type SmsComplianceLog, type SmsComplianceSettings, type SmsConsent, type SmsConsentSource, type SmsConsentStatus, type SmsConsentSummary, type SmsProvider, type SmsProviderConfig, type SmsProviderType, type StepResult, type SubscribeParams, type Subscriber, type SubscriberPreferences, Subscribers, type Subscription, type SubscriptionPeriod, type SubscriptionStatus, type Template, type TemplateAnalytics, type TemplateStatus, Templates, type TestChannelResult, type TestSmsProviderParams, type TestSmsProviderResult, TimeoutError, type TimeseriesParams, type TimeseriesPoint, type TopTemplatesParams, type TriggerWorkflowParams, type TwilioConfig, type UnreadCountResult, type UpdateChannelParams, type UpdateInboxEmbedSettingsParams, type UpdatePaymentMethodParams, type UpdatePreferencesParams, type UpdateSmsComplianceParams, type UpdateSmsProviderParams, type UpdateSubscriberParams, type UpdateTemplateParams, type UpdateWebhookParams, type UpdateWorkflowParams, type ValidateContentParams, type ValidateSmsProviderParams, type ValidateSmsProviderResult, ValidationError, type ValidationResult, type Webhook, type WebhookDelivery, Webhooks, type Workflow, type WorkflowRun, type WorkflowRunStatus, type WorkflowStep, Workflows, type ZenviaConfig };