受限制的短信内容、行业和用例

import * as Twilio from 'twilio';

// Initialize client with environment variables
const client = new Twilio(
  process.env.TWILIO_ACCOUNT_SID,
  process.env.TWILIO_AUTH_TOKEN
);

// Function to validate Chilean phone numbers
const validateChileanNumber = (phone: string): boolean => {
  // Chilean numbers: +56 9 XXXX XXXX
  return /^\+56[9][0-9]{8}$/.test(phone);
};

async function sendSMSToChile(
  to: string,
  message: string
): Promise<void> {
  try {
    if (!validateChileanNumber(to)) {
      throw new Error('Invalid Chilean phone number format');
    }

    const response = await client.messages.create({
      body: message,
      to: to,
      from: process.env.TWILIO_PHONE_NUMBER,
      // Optional: statusCallback URL for delivery updates
      statusCallback: 'https://your-callback-url.com/status'
    });

    console.log(`Message sent successfully: ${response.sid}`);
  } catch (error) {
    console.error('Error sending message:', error);
    throw error;
  }
}

import { SinchClient } from '@sinch/sdk-core';

class ChileSMSService {
  private client: SinchClient;

  constructor() {
    this.client = new SinchClient({
      projectId: process.env.SINCH_PROJECT_ID,
      keyId: process.env.SINCH_KEY_ID,
      keySecret: process.env.SINCH_KEY_SECRET
    });
  }

  async sendMessage(
    phoneNumber: string,
    message: string
  ): Promise<void> {
    try {
      const response = await this.client.sms.batches.send({
        sendSMSRequestBody: {
          to: [phoneNumber],
          from: process.env.SINCH_SENDER_ID,
          body: message,
          // Chile-specific delivery report
          deliveryReport: 'summary'
        }
      });

      console.log('Message batch ID:', response.id);
    } catch (error) {
      console.error('Sinch SMS error:', error);
      throw error;
    }
  }
}

import { MessageBird } from 'messagebird';

class ChileMessageService {
  private client: MessageBird;

  constructor() {
    this.client = new MessageBird(process.env.MESSAGEBIRD_API_KEY);
  }

  async sendSMS(
    recipient: string,
    content: string
  ): Promise<void> {
    const params = {
      originator: process.env.MESSAGEBIRD_ORIGINATOR,
      recipients: [recipient],
      body: content,
      // Chile-specific parameters
      datacoding: 'auto',
      type: 'sms'
    };

    try {
      const response = await new Promise((resolve, reject) => {
        this.client.messages.create(params, (err, response) => {
          if (err) reject(err);
          resolve(response);
        });
      });

      console.log('MessageBird response:', response);
    } catch (error) {
      console.error('MessageBird error:', error);
      throw error;
    }
  }
}

import * as plivo from 'plivo';

class ChilePlivoService {
  private client: plivo.Client;

  constructor() {
    this.client = new plivo.Client(
      process.env.PLIVO_AUTH_ID,
      process.env.PLIVO_AUTH_TOKEN
    );
  }

  async sendSMS(
    destination: string,
    text: string
  ): Promise<void> {
    try {
      const response = await this.client.messages.create({
        src: process.env.PLIVO_SOURCE_NUMBER,
        dst: destination,
        text: text,
        // Chile-specific options
        url: 'https://your-callback-url.com/status',
        method: 'POST'
      });

      console.log('Message UUID:', response.messageUuid);
    } catch (error) {
      console.error('Plivo error:', error);
      throw error;
    }
  }
}