import type { HttpClient } from "../client/HttpClient";
import type { Result } from "../types/Result";
import { MNotifyError } from "../errors/MNotifyError";
/**
 * SMS Template
 */
export interface Template {
    id: string;
    name: string;
    content: string;
    status: "approved" | "pending" | "rejected";
    created_at: string;
    updated_at: string;
}
/**
 * Template creation input
 */
export interface CreateTemplateInput {
    name: string;
    content: string;
}
/**
 * Service for managing SMS templates with mNotify API
 */
export declare class TemplateService {
    private readonly client;
    constructor(client: HttpClient);
    private annotate;
    /**
     * Creates a new SMS template (railway-oriented programming)
     * @param input - Template data
     * @returns Result containing created template or error
     *
     * @example
     * ```typescript
     * const result = await templateService.createTemplateSafe({
     *   name: 'Welcome Message',
     *   content: 'Welcome {{name}} to our service!'
     * });
     * result.match({
     *   ok: (template) => console.log('Template created:', template),
     *   err: (error) => console.error('Failed to create template:', error)
     * });
     * ```
     */
    createTemplateSafe(input: CreateTemplateInput): Promise<Result<Template, MNotifyError>>;
    /**
     * Creates a new SMS template (throws on error - legacy API)
     * @param input - Template data
     * @returns Created template
     * @throws {MNotifyError} On API failure
     *
     * @example
     * ```typescript
     * const template = await templateService.createTemplate({
     *   name: 'Welcome Message',
     *   content: 'Welcome {{name}} to our service!'
     * });
     * ```
     */
    createTemplate(input: CreateTemplateInput): Promise<Template>;
    /**
     * Retrieves all templates (railway-oriented programming)
     * @returns Result containing array of templates or error
     *
     * @example
     * ```typescript
     * const result = await templateService.getTemplatesSafe();
     * if (result.isOk()) {
     *   console.log('Templates:', result.value);
     * }
     * ```
     */
    getTemplatesSafe(): Promise<Result<Template[], MNotifyError>>;
    /**
     * Retrieves all templates (throws on error - legacy API)
     * @returns Array of templates
     * @throws {MNotifyError} On API failure
     *
     * @example
     * ```typescript
     * const templates = await templateService.getTemplates();
     * console.log('Templates:', templates);
     * ```
     */
    getTemplates(): Promise<Template[]>;
    /**
     * Retrieves a specific template by ID (railway-oriented programming)
     * @param id - Template ID
     * @returns Result containing template details or error
     *
     * @example
     * ```typescript
     * const result = await templateService.getTemplateSafe('template_123');
     * result.match({
     *   ok: (template) => console.log('Template:', template),
     *   err: (error) => console.error('Failed to get template:', error)
     * });
     * ```
     */
    getTemplateSafe(id: string): Promise<Result<Template, MNotifyError>>;
    /**
     * Retrieves a specific template by ID (throws on error - legacy API)
     * @param id - Template ID
     * @returns Template details
     * @throws {MNotifyError} On API failure
     *
     * @example
     * ```typescript
     * const template = await templateService.getTemplate('template_123');
     * console.log('Template:', template);
     * ```
     */
    getTemplate(id: string): Promise<Template>;
    /**
     * Deletes a template (railway-oriented programming)
     * @param id - Template ID
     * @returns Result containing deletion confirmation or error
     *
     * @example
     * ```typescript
     * const result = await templateService.deleteTemplateSafe('template_123');
     * if (result.isOk()) {
     *   console.log('Template deleted successfully');
     * }
     * ```
     */
    deleteTemplateSafe(id: string): Promise<Result<{
        status: string;
        message: string;
    }, MNotifyError>>;
    /**
     * Deletes a template (throws on error - legacy API)
     * @param id - Template ID
     * @returns Deletion confirmation
     * @throws {MNotifyError} On API failure
     *
     * @example
     * ```typescript
     * await templateService.deleteTemplate('template_123');
     * ```
     */
    deleteTemplate(id: string): Promise<{
        status: string;
        message: string;
    }>;
}