@sinch/functions-runtime 0.1.0-beta.28

package/dist/index.d.ts

@@ -0,0 +1,1359 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { ConversationService } from '@sinch/conversation';
+import { NumbersService } from '@sinch/numbers';
+import { SmsService } from '@sinch/sms';
+import { Voice, VoiceService } from '@sinch/voice';
+import { Express as Express$1, NextFunction, Request as Request$1, Response as Response$1 } from 'express';
+
+/**
+ * SVAML (Sinch Voice Application Markup Language) types
+ *
+ * These are internal types used by the builders. Users should use the builders
+ * (createIceBuilder, createAceBuilder, createPieBuilder, createMenu) rather
+ * than constructing SVAML responses directly.
+ *
+ * For SDK types, import directly from '@sinch/voice':
+ * ```typescript
+ * import type { Voice } from '@sinch/voice';
+ * // Use Voice.IceResponse, Voice.SvamlAction, etc.
+ * ```
+ */
+/** Text-to-speech instruction */
+export interface SayInstruction {
+	name: "say";
+	text: string;
+	locale?: string;
+}
+/** Play single audio file instruction */
+export interface PlayInstruction {
+	name: "play";
+	url: string;
+}
+/** Play multiple audio files instruction */
+export interface PlayFilesInstruction {
+	name: "playFiles";
+	ids: string[];
+	locale?: string;
+}
+/** Start call recording instruction */
+export interface StartRecordingInstruction {
+	name: "startRecording";
+	options?: {
+		destinationUrl?: string;
+		credentials?: string;
+		format?: string;
+		notificationEvents?: boolean;
+		transcriptionEnabled?: boolean;
+		transcriptionLocale?: string;
+	};
+}
+/** Stop call recording instruction */
+export interface StopRecordingInstruction {
+	name: "stopRecording";
+}
+/** Set cookie instruction (persists data across callbacks) */
+export interface SetCookieInstruction {
+	name: "setCookie";
+	key: string;
+	value: string;
+}
+/** Answer the call instruction */
+export interface AnswerInstruction {
+	name: "answer";
+}
+/** Send DTMF tones instruction */
+export interface SendDtmfInstruction {
+	name: "sendDtmf";
+	value: string;
+}
+/** Union type for all SVAML instructions */
+export type SvamletInstruction = SayInstruction | PlayInstruction | PlayFilesInstruction | StartRecordingInstruction | StopRecordingInstruction | SetCookieInstruction | AnswerInstruction | SendDtmfInstruction;
+/** Base action with name */
+export interface BaseAction {
+	name: string;
+}
+/** Hangup action */
+export interface HangupAction extends BaseAction {
+	name: "hangup";
+}
+/** Continue action */
+export interface ContinueAction extends BaseAction {
+	name: "continue";
+}
+/** Connect to PSTN action */
+export interface ConnectPstnAction extends BaseAction {
+	name: "connectPstn";
+	number: string;
+	cli?: string;
+	maxDuration?: number;
+	timeout?: number;
+	enableAce?: boolean;
+	enableDice?: boolean;
+	enablePie?: boolean;
+	dtmf?: string;
+	custom?: string;
+	indications?: string;
+	amd?: {
+		enabled: boolean;
+	};
+}
+/** Connect to SIP action */
+export interface ConnectSipAction extends BaseAction {
+	name: "connectSip";
+	destination: string;
+	cli?: string;
+	headers?: Record<string, string>;
+	custom?: string;
+}
+/** Connect to MXP (Sinch SDK) action */
+export interface ConnectMxpAction extends BaseAction {
+	name: "connectMxp";
+	destination: string;
+	cli?: string;
+	custom?: string;
+}
+/** Connect to conference action */
+export interface ConnectConfAction extends BaseAction {
+	name: "connectConf";
+	conferenceId: string;
+	moh?: string;
+	enableDice?: boolean;
+	custom?: string;
+}
+/** Park (hold) action */
+export interface ParkAction extends BaseAction {
+	name: "park";
+	holdPrompt?: string;
+	maxDuration?: number;
+	custom?: string;
+}
+/** Run IVR menu action */
+export interface RunMenuAction extends BaseAction {
+	name: "runMenu";
+	menus: Menu[];
+	barge?: boolean;
+	enableDice?: boolean;
+	custom?: string;
+}
+/** Union type for all SVAML actions */
+export type SvamletAction = HangupAction | ContinueAction | ConnectPstnAction | ConnectSipAction | ConnectMxpAction | ConnectConfAction | ParkAction | RunMenuAction;
+/** Menu option definition */
+export interface MenuOption {
+	dtmf: string;
+	action: string;
+}
+/** Menu definition */
+export interface Menu {
+	id: string;
+	mainPrompt: string;
+	repeatPrompt?: string;
+	options: MenuOption[];
+	repeats?: number;
+	maxDigits?: number;
+	timeoutMills?: number;
+	locale?: string;
+}
+/**
+ * Complete SVAML response structure
+ *
+ * Every voice callback must return a SvamletResponse (or null for DICE).
+ */
+export interface SvamletResponse {
+	/** Instructions to execute before the action */
+	instructions?: SvamletInstruction[];
+	/** Action to take after instructions complete */
+	action: SvamletAction;
+}
+/**
+ * Valid DTMF keys for menu options
+ */
+export type DtmfKey = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "*" | "#";
+/**
+ * Menu action types
+ * - 'return' - Return to PIE callback with DTMF value
+ * - 'return(value)' - Return to PIE callback with custom value
+ * - 'menu(menuId)' - Navigate to submenu
+ */
+export type MenuAction = "return" | `return(${string})` | `menu(${string})`;
+/**
+ * Complete menu structure for runMenu action
+ */
+export interface MenuStructure {
+	/** Enable barge-in (interrupt prompts with input) */
+	barge: boolean;
+	/** Array of menu definitions */
+	menus: Menu[];
+}
+/**
+ * Language option for language selection menu template
+ */
+export interface LanguageOption {
+	/** DTMF key to press */
+	dtmf: DtmfKey;
+	/** Display name of the language */
+	name: string;
+	/** Locale code to return (e.g., 'en-US') */
+	value: string;
+}
+/**
+ * Simple menu option for quick menu creation
+ */
+export interface SimpleMenuOption {
+	/** DTMF key */
+	dtmf: string;
+	/** Menu action */
+	action: string;
+}
+/**
+ * Menu builder for creating voice IVR menus with validation
+ *
+ * @example
+ * ```typescript
+ * // Simple menu
+ * const menu = new MenuBuilder()
+ *   .prompt('Press 1 for sales, 2 for support')
+ *   .option('1', 'return(sales)')
+ *   .option('2', 'return(support)')
+ *   .build();
+ *
+ * // Multi-level menu with submenus
+ * const menu = new MenuBuilder()
+ *   .prompt('Press 1 for English, 2 for Spanish')
+ *   .option('1', 'menu(english)')
+ *   .option('2', 'menu(spanish)')
+ *   .addSubmenu('english')
+ *   .prompt('Press 1 for sales, 2 for support')
+ *   .option('1', 'return(en-sales)')
+ *   .option('2', 'return(en-support)')
+ *   .build();
+ * ```
+ */
+export declare class MenuBuilder {
+	private menuStructure;
+	private currentMenu;
+	/**
+	 * Create a new MenuBuilder
+	 *
+	 * @param id - Menu ID (must be 'main' for root menu)
+	 * @throws Error if id is not 'main' for root menu
+	 */
+	constructor(id?: string);
+	/**
+	 * Set the main prompt for the menu
+	 *
+	 * @param text - The prompt text (will be wrapped in TTS tags)
+	 * @param locale - Voice locale (default: 'en-US')
+	 */
+	prompt(text: string, locale?: string): this;
+	/**
+	 * Set the repeat prompt (played when user doesn't respond)
+	 *
+	 * @param text - The repeat prompt text
+	 */
+	repeatPrompt(text: string): this;
+	/**
+	 * Add a menu option
+	 *
+	 * @param dtmf - The DTMF key (0-9, *, #)
+	 * @param action - Action: 'return', 'return(value)', or 'menu(menuid)'
+	 * @throws Error if DTMF key or action is invalid
+	 */
+	option(dtmf: string, action?: string): this;
+	/**
+	 * Set maximum number of digits to collect
+	 *
+	 * @param digits - Maximum digits (1-20)
+	 * @throws Error if digits is out of range
+	 */
+	maxDigits(digits: number): this;
+	/**
+	 * Set timeout in milliseconds
+	 *
+	 * @param ms - Timeout in milliseconds (1000-30000)
+	 * @throws Error if timeout is out of range
+	 */
+	timeout(ms: number): this;
+	/**
+	 * Set number of times to repeat the menu
+	 *
+	 * @param count - Number of repeats (0-5)
+	 * @throws Error if count is out of range
+	 */
+	repeats(count: number): this;
+	/**
+	 * Enable/disable barge-in (allow interrupting prompts with input)
+	 *
+	 * @param enabled - Whether to allow barge-in (default: true)
+	 */
+	barge(enabled?: boolean): this;
+	/**
+	 * Add the current menu and start a new submenu
+	 *
+	 * @param id - Menu ID for the submenu
+	 * @throws Error if submenu ID is invalid
+	 */
+	addSubmenu(id: string): this;
+	/**
+	 * Build and return the complete menu structure
+	 *
+	 * @throws Error if menu structure is invalid
+	 */
+	build(): MenuStructure;
+	/**
+	 * Get just the menus array (for use with runMenu action)
+	 */
+	buildMenus(): Menu[];
+	/**
+	 * Validate DTMF key format
+	 */
+	private isValidDtmf;
+	/**
+	 * Validate action format
+	 */
+	private isValidAction;
+}
+/**
+ * Create a new MenuBuilder
+ *
+ * @param id - Menu ID (defaults to 'main')
+ */
+export declare function createMenu(id?: string): MenuBuilder;
+/**
+ * Create a simple menu quickly
+ *
+ * @param prompt - Main prompt text
+ * @param options - Array of menu options
+ */
+export declare function createSimpleMenu(prompt: string, options?: SimpleMenuOption[]): MenuStructure;
+/**
+ * Pre-built menu templates for common use cases
+ */
+export declare const MenuTemplates: {
+	/**
+	 * Standard business menu (Sales, Support, Operator)
+	 *
+	 * @param companyName - Company name for greeting
+	 */
+	readonly business: (companyName?: string) => MenuStructure;
+	/**
+	 * Yes/No confirmation menu
+	 *
+	 * @param question - Question to ask
+	 */
+	readonly yesNo: (question?: string) => MenuStructure;
+	/**
+	 * Language selection menu
+	 *
+	 * @param languages - Language options
+	 */
+	readonly language: (languages?: LanguageOption[]) => MenuStructure;
+	/**
+	 * After hours menu
+	 *
+	 * @param companyName - Company name
+	 * @param businessHours - Business hours text
+	 */
+	readonly afterHours: (companyName?: string, businessHours?: string) => MenuStructure;
+	/**
+	 * Recording consent menu
+	 */
+	readonly recordingConsent: () => MenuStructure;
+	/**
+	 * Numeric input menu (for collecting multi-digit input like account numbers)
+	 *
+	 * @param prompt - Instructions for user
+	 * @param digits - Number of digits to collect (default: 4)
+	 */
+	readonly numericInput: (prompt: string, digits?: number) => MenuStructure;
+};
+export interface RecordingOptions {
+	/** URL to send the recording to */
+	destinationUrl?: string;
+	/** Credentials for the destination */
+	credentials?: string;
+	/** Recording format */
+	format?: "mp3" | "wav";
+	/** Enable notification events */
+	notificationEvents?: boolean;
+	/** Enable transcription */
+	transcriptionEnabled?: boolean;
+	/** Transcription locale */
+	transcriptionLocale?: string;
+}
+export interface ConnectPstnOptions {
+	/** CLI (Caller ID) to display */
+	cli?: string;
+	/** Maximum duration in seconds */
+	maxDuration?: number;
+	/** Timeout in seconds */
+	timeout?: number;
+	/** Enable ACE callback */
+	enableAce?: boolean;
+	/** Enable DICE callback */
+	enableDice?: boolean;
+	/** Enable PIE callback */
+	enablePie?: boolean;
+	/** DTMF to send on connect */
+	dtmf?: string;
+	/** Custom data to pass to callbacks */
+	custom?: string;
+	/** Dial tone indications */
+	indications?: "se" | "us" | "no" | "fi" | "uk" | "de" | "fr";
+	/** Enable AMD (Answering Machine Detection) */
+	amd?: {
+		enabled: boolean;
+	};
+}
+export interface ConnectSipOptions {
+	/** CLI (Caller ID) to display */
+	cli?: string;
+	/** Custom SIP headers */
+	headers?: Record<string, string>;
+	/** Custom data to pass to callbacks */
+	custom?: string;
+}
+export interface ConnectMxpOptions {
+	/** CLI (Caller ID) to display */
+	cli?: string;
+	/** Custom data to pass to callbacks */
+	custom?: string;
+}
+export interface ConnectConfOptions {
+	/** Music on hold */
+	moh?: "ring" | "music";
+	/** Enable DICE callback */
+	enableDice?: boolean;
+	/** Custom data to pass to callbacks */
+	custom?: string;
+}
+export interface ParkOptions {
+	/** Maximum park duration in seconds */
+	maxDuration?: number;
+	/** Custom data to pass to callbacks */
+	custom?: string;
+}
+export interface RunMenuOptions {
+	/** Allow user to interrupt prompts */
+	barge?: boolean;
+	/** Enable DICE callback */
+	enableDice?: boolean;
+	/** Custom data to pass to callbacks */
+	custom?: string;
+}
+declare abstract class BaseSvamlBuilder<T extends BaseSvamlBuilder<T>> {
+	protected instructions: SvamletInstruction[];
+	protected action: SvamletAction | null;
+	/**
+	 * Add a text-to-speech instruction
+	 *
+	 * @param text - Text to speak
+	 * @param locale - Voice locale (e.g., 'en-US')
+	 */
+	say(text: string, locale?: string): T;
+	/**
+	 * Play an audio file
+	 *
+	 * @param url - URL of the audio file to play
+	 */
+	play(url: string): T;
+	/**
+	 * Play multiple audio files
+	 *
+	 * @param urls - Array of audio file URLs
+	 * @param locale - Locale for any TTS prompts
+	 */
+	playFiles(urls: string[], locale?: string): T;
+	/**
+	 * Start recording the call
+	 *
+	 * @param options - Recording options
+	 */
+	startRecording(options?: RecordingOptions): T;
+	/**
+	 * Stop recording the call
+	 */
+	stopRecording(): T;
+	/**
+	 * Set a cookie (persists data across callbacks)
+	 *
+	 * @param key - Cookie key
+	 * @param value - Cookie value
+	 */
+	setCookie(key: string, value: string): T;
+	/**
+	 * Send DTMF tones
+	 *
+	 * @param digits - DTMF digits to send
+	 */
+	sendDtmf(digits: string): T;
+	/**
+	 * Hang up the call
+	 */
+	hangup(): T;
+	/**
+	 * Continue to next callback
+	 */
+	continue(): T;
+	/**
+	 * Build the final SVAML response
+	 *
+	 * @throws Error if no action has been set
+	 */
+	build(): SvamletResponse;
+}
+/**
+ * ICE (Incoming Call Event) SVAML Builder
+ *
+ * Use this to build responses for incoming call events.
+ *
+ * @example
+ * ```typescript
+ * export async function ice(context, event) {
+ *   return new IceSvamlBuilder()
+ *     .say('Welcome! Connecting you now.')
+ *     .connectPstn('+15551234567')
+ *     .build();
+ * }
+ * ```
+ */
+export declare class IceSvamlBuilder extends BaseSvamlBuilder<IceSvamlBuilder> {
+	/**
+	 * Answer the call explicitly
+	 */
+	answer(): this;
+	/**
+	 * Connect to a PSTN phone number
+	 *
+	 * @param number - E.164 formatted phone number (e.g., '+15551234567')
+	 * @param options - Connection options
+	 */
+	connectPstn(number: string, options?: ConnectPstnOptions): this;
+	/**
+	 * Connect to a SIP endpoint
+	 *
+	 * @param destination - SIP URI
+	 * @param options - Connection options
+	 */
+	connectSip(destination: string, options?: ConnectSipOptions): this;
+	/**
+	 * Connect to an MXP (Sinch SDK) user
+	 *
+	 * @param destination - MXP user identifier
+	 * @param options - Connection options
+	 */
+	connectMxp(destination: string, options?: ConnectMxpOptions): this;
+	/**
+	 * Join a conference
+	 *
+	 * @param conferenceId - Conference ID to join
+	 * @param options - Conference options
+	 */
+	connectConf(conferenceId: string, options?: ConnectConfOptions): this;
+	/**
+	 * Run an IVR menu
+	 *
+	 * @param menus - Array of menu definitions or MenuStructure from createMenu().build()
+	 * @param options - Menu options
+	 */
+	runMenu(menus: Menu[] | MenuStructure, options?: RunMenuOptions): this;
+	/**
+	 * Park the call (put on hold)
+	 *
+	 * @param holdPrompt - Prompt to play while on hold
+	 * @param options - Park options
+	 */
+	park(holdPrompt?: string, options?: ParkOptions): this;
+}
+/**
+ * ACE (Answered Call Event) SVAML Builder
+ *
+ * Use this to build responses for answered call events (outbound calls).
+ *
+ * @example
+ * ```typescript
+ * export async function ace(context, event) {
+ *   if (event.amd?.status === 'machine') {
+ *     return new AceSvamlBuilder().hangup().build();
+ *   }
+ *   return new AceSvamlBuilder()
+ *     .say('Hello! This is a call from Acme Corp.')
+ *     .continue()
+ *     .build();
+ * }
+ * ```
+ */
+export declare class AceSvamlBuilder extends BaseSvamlBuilder<AceSvamlBuilder> {
+}
+/**
+ * PIE (Prompt Input Event) SVAML Builder
+ *
+ * Use this to build responses for user input events (DTMF/voice).
+ *
+ * @example
+ * ```typescript
+ * export async function pie(context, event) {
+ *   const selection = event.menuResult?.value;
+ *
+ *   if (selection === '1') {
+ *     return new PieSvamlBuilder()
+ *       .say('Connecting you to sales.')
+ *       .connectPstn('+15551234567')
+ *       .build();
+ *   }
+ *
+ *   return new PieSvamlBuilder()
+ *     .say('Goodbye!')
+ *     .hangup()
+ *     .build();
+ * }
+ * ```
+ */
+export declare class PieSvamlBuilder extends BaseSvamlBuilder<PieSvamlBuilder> {
+	/**
+	 * Connect to a PSTN phone number
+	 *
+	 * @param number - E.164 formatted phone number
+	 * @param options - Connection options
+	 */
+	connectPstn(number: string, options?: ConnectPstnOptions): this;
+	/**
+	 * Run an IVR menu
+	 *
+	 * @param menus - Array of menu definitions or MenuStructure from createMenu().build()
+	 * @param options - Menu options
+	 */
+	runMenu(menus: Menu[] | MenuStructure, options?: RunMenuOptions): this;
+	/**
+	 * Park the call (put on hold)
+	 *
+	 * @param holdPrompt - Prompt to play while on hold
+	 * @param options - Park options
+	 */
+	park(holdPrompt?: string, options?: ParkOptions): this;
+}
+/**
+ * Create a new ICE SVAML builder
+ */
+export declare function createIceBuilder(): IceSvamlBuilder;
+/**
+ * Create a new ACE SVAML builder
+ */
+export declare function createAceBuilder(): AceSvamlBuilder;
+/**
+ * Create a new PIE SVAML builder
+ */
+export declare function createPieBuilder(): PieSvamlBuilder;
+/**
+ * Cache interface for Sinch Functions
+ *
+ * Both dev (LocalCache) and prod (DaprCache) implement this interface,
+ * allowing seamless package swap during deployment.
+ */
+/**
+ * Function cache interface
+ *
+ * Provides key-value storage with TTL support.
+ * In development, uses in-memory storage.
+ * In production, uses Dapr state store.
+ */
+export interface IFunctionCache {
+	/**
+	 * Store a value with optional TTL
+	 *
+	 * @param key - Cache key
+	 * @param value - Value to store (will be JSON serialized)
+	 * @param ttlSeconds - Time to live in seconds (default: 3600)
+	 */
+	set<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+	/**
+	 * Retrieve a value from cache
+	 *
+	 * @param key - Cache key
+	 * @returns The stored value or null if not found/expired
+	 */
+	get<T = unknown>(key: string): Promise<T | null>;
+	/**
+	 * Check if a key exists in the cache
+	 *
+	 * @param key - Cache key
+	 */
+	has(key: string): Promise<boolean>;
+	/**
+	 * Delete a value from cache
+	 *
+	 * @param key - Cache key
+	 * @returns true if the key existed and was deleted
+	 */
+	delete(key: string): Promise<boolean>;
+	/**
+	 * Extend TTL for a key
+	 *
+	 * @param key - Cache key
+	 * @param additionalSeconds - Additional seconds to add to TTL
+	 * @returns true if the key exists and TTL was extended
+	 */
+	extend(key: string, additionalSeconds: number): Promise<boolean>;
+	/**
+	 * Get all keys matching a pattern
+	 *
+	 * @param pattern - Pattern with * wildcard (default: '*')
+	 * @returns Array of matching keys
+	 */
+	keys(pattern?: string): Promise<string[]>;
+	/**
+	 * Get multiple values at once
+	 *
+	 * @param keys - Array of keys to retrieve
+	 * @returns Object with keys and their values (or null if not found)
+	 */
+	getMany<T = unknown>(keys: string[]): Promise<Record<string, T | null>>;
+}
+/**
+ * Function configuration with environment variables
+ */
+export interface FunctionConfig {
+	/** Project ID */
+	projectId: string;
+	/** Function name */
+	functionName: string;
+	/** Environment (development, production) */
+	environment: "development" | "production";
+	/** Custom environment variables */
+	variables?: Record<string, string>;
+}
+/**
+ * Main function context object passed to all handlers
+ *
+ * Note: Call-specific data like callId is available on the callback event data,
+ * not on the context object.
+ */
+export interface FunctionContext {
+	/** Configuration including environment variables */
+	config: FunctionConfig;
+	/** Cache client for persistent data */
+	cache: IFunctionCache;
+	/** Request ID for tracing */
+	requestId?: string;
+	/** Timestamp of the request */
+	timestamp?: string;
+	/** Environment variables */
+	env?: Record<string, string | undefined>;
+	/** Sinch Voice SDK client (if available) */
+	voice?: VoiceService;
+	/** Sinch Conversation SDK client (if available) */
+	conversation?: ConversationService;
+	/** Sinch SMS SDK client (if available) */
+	sms?: SmsService;
+	/** Sinch Numbers SDK client (if available) */
+	numbers?: NumbersService;
+}
+/**
+ * Application credentials structure
+ */
+export interface ApplicationCredentials {
+	applicationKey: string;
+	applicationSecret: string;
+}
+/**
+ * Configuration summary for debugging
+ */
+export interface ConfigSummary {
+	environment: "production" | "development";
+	variables: Record<string, string | undefined>;
+	secrets: Record<string, string>;
+	hasApplicationCredentials: boolean;
+}
+/**
+ * Universal configuration utility class
+ *
+ * Provides a consistent interface for accessing environment variables,
+ * secrets, and configuration across local and production environments.
+ */
+export declare class UniversalConfig {
+	private context;
+	private env;
+	/**
+	 * Create a new UniversalConfig instance
+	 *
+	 * @param context - Function execution context
+	 */
+	constructor(context: FunctionContext);
+	/**
+	 * Get a secret value (e.g., API keys, passwords, tokens)
+	 *
+	 * @param name - Secret name (e.g., 'PROJECT_ID_API_SECRET')
+	 * @param defaultValue - Optional default value if secret not found
+	 */
+	getSecret(name: string, defaultValue?: string | null): string | null;
+	/**
+	 * Get an environment variable (non-secret configuration)
+	 *
+	 * @param name - Variable name (e.g., 'COMPANY_NAME', 'API_URL')
+	 * @param defaultValue - Optional default value
+	 */
+	getVariable(name: string, defaultValue?: string | null): string | null;
+	/**
+	 * Check if a secret exists (has a value)
+	 *
+	 * @param name - Secret name
+	 */
+	hasSecret(name: string): boolean;
+	/**
+	 * Check if a variable exists (has a value)
+	 *
+	 * @param name - Variable name
+	 */
+	hasVariable(name: string): boolean;
+	/**
+	 * Get required secret (throws error if not found)
+	 *
+	 * @param name - Secret name
+	 * @throws Error if secret is not found
+	 */
+	requireSecret(name: string): string;
+	/**
+	 * Get required variable (throws error if not found)
+	 *
+	 * @param name - Variable name
+	 * @throws Error if variable is not found
+	 */
+	requireVariable(name: string): string;
+	/**
+	 * Get Sinch application credentials
+	 */
+	getApplicationCredentials(): ApplicationCredentials | null;
+	/**
+	 * Check if running in development mode
+	 */
+	isDevelopment(): boolean;
+	/**
+	 * Check if running in production mode
+	 */
+	isProduction(): boolean;
+	/**
+	 * Get cache client instance
+	 */
+	getCache(): IFunctionCache | undefined;
+	/**
+	 * Get comprehensive configuration summary (useful for debugging)
+	 * Excludes actual secret values for security
+	 */
+	getConfigSummary(): ConfigSummary;
+}
+/**
+ * Create a universal config instance for a function execution context
+ *
+ * @param context - Function execution context
+ */
+export declare function createConfig(context: FunctionContext): UniversalConfig;
+export declare const createUniversalConfig: typeof createConfig;
+/**
+ * HTTP request/response types for custom API endpoints
+ */
+/**
+ * HTTP methods supported by function endpoints
+ */
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+/**
+ * HTTP request for custom endpoints
+ *
+ * Abstraction over Express request for user-friendly API handling.
+ */
+export interface FunctionRequest {
+	/** HTTP method */
+	method: HttpMethod;
+	/** Request path */
+	path: string;
+	/** Query parameters */
+	query?: Record<string, string | string[]>;
+	/** Request headers (lowercase keys) */
+	headers?: Record<string, string>;
+	/** Request body (parsed JSON) */
+	body?: unknown;
+	/** Route parameters (e.g., /users/:id) */
+	params?: Record<string, string>;
+}
+/**
+ * HTTP response for custom endpoints
+ *
+ * Return this from custom API handlers to control the response.
+ */
+export interface FunctionResponse {
+	/** HTTP status code (default: 200) */
+	statusCode: number;
+	/** Response headers */
+	headers?: Record<string, string>;
+	/** Response body (will be JSON serialized) */
+	body?: unknown;
+}
+/**
+ * Create a response with custom status code
+ */
+export declare function createResponse<T>(statusCode: number, body?: T, headers?: Record<string, string>): FunctionResponse;
+/**
+ * Create a JSON response
+ */
+export declare function createJsonResponse<T>(body: T, statusCode?: number): FunctionResponse;
+/**
+ * Create an error response
+ */
+export declare function createErrorResponse(message: string, statusCode?: number): FunctionResponse;
+/**
+ * Voice event handler function signature
+ *
+ * @template T - The specific callback data type
+ * @template R - The return type (SVAML or void for notification events)
+ */
+export type VoiceEventHandler<T, R = SvamletResponse | void> = (context: FunctionContext, callbackData: T) => Promise<R>;
+/**
+ * Custom API handler function signature
+ */
+export type ApiHandler = (context: FunctionContext, request: FunctionRequest) => Promise<FunctionResponse | unknown>;
+/**
+ * ICE (Incoming Call Event) handler
+ */
+export type IceHandler = (context: FunctionContext, callbackData: Voice.IceRequest) => Promise<SvamletResponse>;
+/**
+ * ACE (Answered Call Event) handler
+ */
+export type AceHandler = (context: FunctionContext, callbackData: Voice.AceRequest) => Promise<SvamletResponse>;
+/**
+ * PIE (Prompt Input Event) handler
+ */
+export type PieHandler = (context: FunctionContext, callbackData: Voice.PieRequest) => Promise<SvamletResponse>;
+/**
+ * DICE (Disconnect Call Event) handler
+ */
+export type DiceHandler = (context: FunctionContext, callbackData: Voice.DiceRequest) => Promise<void>;
+/**
+ * Notify handler
+ */
+export type NotifyHandler = (context: FunctionContext, callbackData: Voice.NotifyRequest) => Promise<void>;
+/**
+ * Voice function export structure
+ *
+ * This is the shape of the module that users export from function.ts.
+ * The runtime discovers and invokes the appropriate handler based on
+ * the incoming request.
+ *
+ * @example
+ * ```typescript
+ * import type { VoiceFunction } from '@sinch/functions-runtime';
+ * import type { Voice } from '@sinch/voice';
+ *
+ * export default {
+ *   async ice(context, data: Voice.IceRequest) {
+ *     const { cli, to } = data;
+ *     return createIceBuilder().hangup().build();
+ *   }
+ * } satisfies VoiceFunction;
+ * ```
+ */
+export interface VoiceFunction {
+	/** Handle ICE (Incoming Call Event) */
+	ice?: IceHandler;
+	/** Handle ACE (Answered Call Event) */
+	ace?: AceHandler;
+	/** Handle PIE (Prompt Input Event) */
+	pie?: PieHandler;
+	/** Handle DICE (Disconnect Call Event) */
+	dice?: DiceHandler;
+	/** Handle notify events */
+	notify?: NotifyHandler;
+	/** Default handler for GET / */
+	default?: ApiHandler;
+	/** Custom API endpoints (any other exported function) */
+	[key: string]: unknown;
+}
+/**
+ * @deprecated Use VoiceFunction instead. SinchFunction will be removed in a future version.
+ */
+export type SinchFunction = VoiceFunction;
+/**
+ * Options for camelCase key transformation
+ */
+export interface CamelCaseOptions {
+	/** Transform nested objects */
+	deep?: boolean;
+	/** Paths to skip transformation */
+	stopPaths?: string[];
+	/** Keys to exclude from transformation */
+	exclude?: (string | RegExp)[];
+}
+/**
+ * Options for JSON parsing middleware
+ */
+export interface JsonParsingOptions {
+	/** Maximum body size (default: '10mb') */
+	limit?: string;
+	/** Accept JSON5 features (default: true) */
+	allowJson5?: boolean;
+	/** CamelCase transformation options */
+	camelCase?: CamelCaseOptions;
+}
+/**
+ * Extended Express Request with rawBody for signature validation
+ */
+export interface SinchRequest extends Request {
+	rawBody?: string;
+	_keysTransformed?: boolean;
+}
+/**
+ * Convert string to camelCase
+ *
+ * Handles:
+ * - snake_case: call_id -> callId
+ * - kebab-case: call-id -> callId
+ * - lowercase concatenated: callid -> callId
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Deep transform object keys to camelCase
+ */
+export declare function transformKeys<T>(obj: T, options?: CamelCaseOptions): T;
+/**
+ * Parse JSON with fallback to basic JSON5 support
+ */
+export declare function parseJson(text: string, allowJson5?: boolean): unknown;
+/**
+ * Create Express middleware for lenient JSON parsing with camelCase transformation
+ */
+export declare function createLenientJsonParser(options?: JsonParsingOptions): (req: SinchRequest, res: Response, next: NextFunction) => void;
+/**
+ * Setup Express app with JSON parsing middleware
+ */
+export declare function setupJsonParsing(app: Express, options?: JsonParsingOptions): Express;
+/**
+ * Options for creating the Express app
+ */
+export interface AppOptions {
+	/** JSON parsing options */
+	jsonParsingOptions?: JsonParsingOptions;
+	/** Enable landing page for browser requests at root (default: true) */
+	landingPageEnabled?: boolean;
+	/** Directory to serve static files from (optional) */
+	staticDir?: string;
+}
+/**
+ * Options for setting up the request handler
+ */
+export interface RequestHandlerOptions {
+	/** Function to load user code module (can be sync or async for ESM) */
+	loadUserFunction?: () => SinchFunction | Promise<SinchFunction>;
+	/** Function to build context for each request */
+	buildContext?: (req: Request) => FunctionContext;
+	/** Logger function */
+	logger?: (...args: unknown[]) => void;
+	/** Enable landing page for browser requests at root (default: true) */
+	landingPageEnabled?: boolean;
+	/** Called when request starts */
+	onRequestStart?: (data: {
+		functionName: string;
+		req: Request;
+	}) => void;
+	/** Called when request ends */
+	onRequestEnd?: (data: {
+		functionName: string;
+		req: Request;
+		response?: FormattedResponse;
+		error?: Error;
+		duration: number;
+		statusCode: number;
+	}) => void;
+}
+/**
+ * Formatted response structure
+ */
+export interface FormattedResponse {
+	statusCode: number;
+	headers?: Record<string, string>;
+	body?: unknown;
+}
+/** Voice callback function names */
+export declare const VOICE_CALLBACKS: readonly [
+	"ice",
+	"ace",
+	"pie",
+	"dice",
+	"notify"
+];
+/** Notification-only events (don't require SVAML response) */
+export declare const NOTIFICATION_EVENTS: readonly [
+	"dice",
+	"notify"
+];
+export type VoiceCallback = (typeof VOICE_CALLBACKS)[number];
+export type NotificationEvent = (typeof NOTIFICATION_EVENTS)[number];
+/**
+ * Check if a function name is a voice callback
+ */
+export declare function isVoiceCallback(functionName: string): functionName is VoiceCallback;
+/**
+ * Check if a function is a notification-only event
+ */
+export declare function isNotificationEvent(functionName: string): functionName is NotificationEvent;
+/**
+ * Extract function name from request path or body
+ */
+export declare function extractFunctionName(path: string, body?: {
+	event?: string;
+}): string;
+/**
+ * Generate unique request ID
+ */
+export declare function generateRequestId(): string;
+/**
+ * Format SVAML response for voice callbacks
+ */
+export declare function formatSvamlResponse(result: unknown, functionName: string): FormattedResponse;
+/**
+ * Format custom endpoint response
+ */
+export declare function formatCustomResponse(result: unknown): FormattedResponse;
+/**
+ * Validate voice callback request
+ */
+export declare function validateVoiceRequest(body: unknown): {
+	valid: boolean;
+	error?: string;
+	expectedEvents?: string[];
+};
+/**
+ * Build base context object for function execution
+ *
+ * Note: Call-specific data like callId is available on the callback event data,
+ * not on the context object.
+ */
+export declare function buildBaseContext(req: Request, config?: Partial<FunctionConfig>): FunctionContext;
+/**
+ * Handle voice callback execution
+ */
+export declare function handleVoiceCallback(functionName: string, userFunction: SinchFunction, context: FunctionContext, callbackData: unknown, logger?: (...args: unknown[]) => void): Promise<FormattedResponse>;
+/**
+ * Handle custom endpoint execution
+ */
+export declare function handleCustomEndpoint(functionName: string, userFunction: SinchFunction, context: FunctionContext, request: FunctionRequest, logger?: (...args: unknown[]) => void): Promise<FormattedResponse>;
+/**
+ * Create and configure Express app with standard middleware
+ */
+export declare function createApp(options?: AppOptions): Express;
+/**
+ * Setup the main request handler
+ */
+export declare function setupRequestHandler(app: Express, options?: RequestHandlerOptions): void;
+export interface SinchClients {
+	voice?: VoiceService;
+	conversation?: ConversationService;
+	sms?: SmsService;
+	numbers?: NumbersService;
+	validateWebhookSignature?: (requestData: WebhookRequestData) => boolean;
+}
+export interface WebhookRequestData {
+	method: string;
+	path: string;
+	headers: Record<string, string>;
+	body: string;
+}
+/**
+ * Get or create Sinch clients (with caching)
+ */
+export declare function getSinchClients(): SinchClients;
+/**
+ * Reset cached clients (useful for testing)
+ */
+export declare function resetSinchClients(): void;
+/**
+ * Simple template renderer for HTML files
+ * Replaces {{variableName}} placeholders with actual values
+ */
+export declare class TemplateRender {
+	/**
+	 * Load and render an HTML template with variables
+	 * @param templatePath - Path to the HTML template file
+	 * @param variables - Object containing variables to replace in template
+	 * @returns Rendered HTML string
+	 */
+	static render(templatePath: string, variables?: Record<string, any>): string;
+	/**
+	 * Get the absolute path to a template file relative to the current directory
+	 * @param templateName - Name of the template file (e.g., 'index.html')
+	 * @param baseDir - Base directory to search from (defaults to cwd)
+	 * @returns Absolute path to the template file
+	 */
+	static getTemplatePath(templateName: string, baseDir?: string): string;
+}
+/**
+ * Version extractor utility for reading template versions from README.md files
+ */
+export declare class VersionExtractor {
+	/**
+	 * Extract version from README.md file in the template directory
+	 * Looks for "Template Version: X.X.X" pattern in the last few lines
+	 * @param templateDir - Path to the template directory containing README.md
+	 * @returns Version string or default fallback
+	 */
+	static getTemplateVersion(templateDir?: string): string;
+}
+export interface DefaultEndpointOptions {
+	serviceName?: string;
+	companyName?: string;
+	templateVersion?: string;
+	availableEndpoints?: Record<string, string>;
+}
+export interface HttpRequest {
+	method: string;
+	path: string;
+	query?: Record<string, any>;
+	headers?: Record<string, string>;
+	body?: any;
+	params?: Record<string, string>;
+}
+export interface HttpResponse {
+	statusCode: number;
+	headers: Record<string, string>;
+	body: any;
+}
+export declare class DefaultEndpointHandler {
+	/**
+	 * Handle the default endpoint with content negotiation
+	 * @param context - Function context with config and cache
+	 * @param request - HTTP request object with method, path, query, headers, body, params
+	 * @param options - Configuration options for the response
+	 * @returns HTTP response object with statusCode, headers, and body
+	 */
+	static handle(context: FunctionContext, request: HttpRequest, options?: DefaultEndpointOptions): Promise<HttpResponse>;
+}
+/** @deprecated Import from '@sinch/voice' instead: `import type { Voice } from '@sinch/voice'` then use `Voice.IceRequest` */
+export type IceCallbackData = Voice.IceRequest;
+/** @deprecated Import from '@sinch/voice' instead */
+export type AceCallbackData = Voice.AceRequest;
+/** @deprecated Import from '@sinch/voice' instead */
+export type PieCallbackData = Voice.PieRequest;
+/** @deprecated Import from '@sinch/voice' instead */
+export type DiceCallbackData = Voice.DiceRequest;
+/** @deprecated Import from '@sinch/voice' instead */
+export type NotifyCallbackData = Voice.NotifyRequest;
+/** @deprecated Import from '@sinch/voice' instead */
+export type MenuResult = Voice.MenuResult;
+/** @deprecated Import from '@sinch/voice' instead */
+export type AmdResult = Voice.AnsweringMachineDetection;
+/** @deprecated Import from '@sinch/voice' instead */
+export type DisconnectReason = Voice.DiceReasonEnum;
+/** @deprecated Import from '@sinch/voice' instead */
+export type CallResult = Voice.ResultEnum;
+/**
+ * Union type for all voice callback data
+ */
+export type VoiceCallbackData = Voice.IceRequest | Voice.AceRequest | Voice.PieRequest | Voice.DiceRequest | Voice.NotifyRequest;
+/**
+ * Local cache client for development
+ *
+ * Implements IFunctionCache using an in-memory Map with TTL support.
+ * Data is lost when the process restarts.
+ */
+export declare class LocalCache implements IFunctionCache {
+	private cache;
+	constructor();
+	set<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+	get<T = unknown>(key: string): Promise<T | null>;
+	has(key: string): Promise<boolean>;
+	delete(key: string): Promise<boolean>;
+	extend(key: string, additionalSeconds: number): Promise<boolean>;
+	keys(pattern?: string): Promise<string[]>;
+	getMany<T = unknown>(keys: string[]): Promise<Record<string, T | null>>;
+	/**
+	 * Clear all entries from the cache
+	 * (Utility method for testing)
+	 */
+	clear(): Promise<void>;
+	/**
+	 * Get the number of entries in the cache
+	 * (Utility method for debugging)
+	 */
+	get size(): number;
+}
+/**
+ * Factory function to create a cache client
+ *
+ * @param _projectId - Project ID (unused in local development)
+ * @param _functionName - Function name (unused in local development)
+ */
+export declare function createCacheClient(_projectId?: string, _functionName?: string): IFunctionCache;
+/**
+ * Tunnel Client for Sinch Functions
+ *
+ * Connects to the Sinch Functions API via WebSocket to receive
+ * incoming voice callbacks during local development.
+ */
+export declare class TunnelClient {
+	private ws;
+	private tunnelUrl;
+	private isConnected;
+	private reconnectAttempts;
+	private maxReconnectAttempts;
+	private reconnectDelay;
+	private heartbeatInterval;
+	private localPort;
+	constructor(localPort?: number);
+	connect(): Promise<void>;
+	private handleMessage;
+	private handleRequest;
+	private sendPong;
+	private startHeartbeat;
+	private stopHeartbeat;
+	private displayTestPhoneNumbers;
+	private scheduleReconnect;
+	disconnect(): void;
+	getTunnelUrl(): string | null;
+	getIsConnected(): boolean;
+}
+export declare function getTunnelClient(localPort?: number): TunnelClient;
+/**
+ * Secrets Loader for Local Development
+ *
+ * Loads secrets from OS keychain (Windows Credential Manager, macOS Keychain, Linux Secret Service)
+ * using the same storage pattern as the Sinch CLI. This enables F5 debugging in VS Code
+ * without needing to run 'sinch functions dev'.
+ *
+ * Security: Only loads secrets that are declared in .env file (empty values)
+ * In production, secrets are injected by the platform, so this is development-only.
+ */
+export declare class SecretsLoader {
+	private SERVICE_NAME;
+	private username;
+	/**
+	 * Load secrets from OS keychain for variables declared in .env
+	 * Only loads secrets that have empty values in .env (security best practice)
+	 */
+	loadFromKeychain(): Promise<boolean>;
+	/**
+	 * Helper to get application key from sinch.json
+	 */
+	private getApplicationKeyFromConfig;
+	/**
+	 * Helper to get function name from sinch.json
+	 */
+	private getFunctionNameFromConfig;
+	/**
+	 * Load custom secrets added via 'sinch functions secrets' command
+	 */
+	loadCustomSecrets(secretNames?: string[]): Promise<Record<string, string>>;
+	/**
+	 * Check if keytar is available
+	 */
+	isAvailable(): Promise<boolean>;
+}
+export declare const secretsLoader: SecretsLoader;
+
+export {
+	CamelCaseOptions as ParserCamelCaseOptions,
+	JsonParsingOptions as ParserOptions,
+	createLenientJsonParser as createJsonParser,
+	parseJson as parseJsonLenient,
+	setupJsonParsing as setupJsonMiddleware,
+	toCamelCase as convertToCamelCase,
+	transformKeys as transformKeysToCamelCase,
+};
+
+export {};