openapi: 3.0.0
info:
  title: Email To SMS
  description: Everything about Email to SMS
servers:
  - url: https://rest.clicksend.com
components:
  securitySchemes:
    basicAuth:
      type: http
      scheme: basic
  schemas:
    view-allowed-emails:
      type: object
      properties:
        http_code:
          type: integer
          description: The HTTP status code of the response.
          example: 200
        response_code:
          type: string
          description: The response code indicating the status of the operation.
          example: SUCCESS
        response_msg:
          type: string
          description: A message describing the outcome of the operation.
          example: Here are some data.
        data:
          type: array
          items:
            type: object
            properties:
              email_address_id:
                type: number
                example: 1
                description: The ID of the email address.
              email_address:
                type: string
                example: my@email.com
                description: The email address.
              from:
                type: string
                example: '+13523944199'
                description: The sender.
          example:
            - email_address_id: 84
              email_address: my@email.com
              from: '+13523944199'
            - email_address_id: 85
              email_address: my@email.com
              from: '+13523944199'
    add-allowed-email:
      type: object
      properties:
        http_code:
          type: integer
          description: The HTTP status code of the response.
          example: 200
        response_code:
          type: string
          description: The response code indicating the status of the operation.
          example: SUCCESS
        response_msg:
          type: string
          description: A message describing the outcome of the operation.
          example: New data has been saved.
        data:
          type: object
          properties:
            email_address_id:
              type: number
              example: 107
              description: The ID of the email address.
            email_address:
              type: string
              example: Cv3p0@gmail.com
              description: The email address.
            from:
              type: string
              example: '+17128845887'
              description: The sender.
    view-stripped-string-rules:
      type: object
      properties:
        http_code:
          type: integer
          description: The HTTP status code of the response.
          example: 200
        response_code:
          type: string
          description: The response code indicating the status of the operation.
          example: SUCCESS
        response_msg:
          type: string
          description: A message describing the outcome of the operation.
          example: New data has been saved.
        data:
          type: object
          properties:
            total:
              type: integer
              description: The total number of records in the response.
              example: 2
            per_page:
              type: integer
              description: The number of records per page.
              example: 15
            current_page:
              type: integer
              description: The current page number.
              example: 1
            last_page:
              type: integer
              description: The last page number.
              example: 1
            next_page_url:
              type: string
              nullable: true
              description: The URL of the next page of records.
              example: null
            prev_page_url:
              type: string
              nullable: true
              description: The URL of the previous page of records.
              example: null
            data:
              type: array
              items:
                type: object
                properties:
                  rule_id:
                    type: integer
                    description: The ID of the rule.
                  strip_string:
                    type: string
                    description: The string to be stripped.
              example:
                - rule_id: 18
                  strip_string: This is a test1.
                - rule_id: 19
                  strip_string: This is a test2.
    create-stripped-string-rule:
      type: object
      properties:
        http_code:
          type: integer
          description: The HTTP status code of the response.
          example: 200
        response_code:
          type: string
          description: The response code indicating the status of the operation.
          example: SUCCESS
        response_msg:
          type: string
          description: A message describing the outcome of the operation.
          example: Strip string has been created.
        data:
          type: object
          properties:
            rule_id:
              type: integer
              description: The ID of the created strip string rule.
              example: 20
            strip_string:
              type: string
              description: The created strip string.
              example: test
    view-stripped-string-rule:
      type: object
      properties:
        http_code:
          type: integer
          description: The HTTP status code of the response.
          example: 200
        response_code:
          type: string
          description: The response code indicating the status of the operation.
          example: SUCCESS
        response_msg:
          type: string
          description: A message describing the outcome of the operation.
          example: Here is your result.
        data:
          type: object
          properties:
            rule_id:
              type: integer
              description: The rule id
              example: 18
            stripped_string:
              type: string
              description: The string to be stripped
              example: You've received a reply from.
    update-stripped-string-rule:
      type: object
      properties:
        http_code:
          type: integer
          description: The HTTP status code of the response.
          example: 200
        response_code:
          type: string
          description: The response code indicating the status of the operation.
          example: SUCCESS
        response_msg:
          type: string
          description: A message describing the outcome of the operation.
          example: Strip string has been updated.
        data:
          type: object
          properties:
            rule_id:
              type: integer
              example: 20
              description: The rule id
            stripped_string:
              type: string
              example: ~~~~test1~~~~
              description: The stripped string
    delete-stripped-string-rule:
      type: object
      properties:
        http_code:
          type: integer
          description: The HTTP status code of the response.
          example: 200
        response_code:
          type: string
          description: The response code indicating the status of the operation.
          example: SUCCESS
        response_msg:
          type: string
          description: A message describing the outcome of the operation.
          example: Strip string has been deleted.
        data:
          type: boolean
          example: true
paths:
  /v3/sms/email-sms:
    get:
      summary: View Allowed Emails
      operationId: view-allowed-emails
      description: >-
        _Get list of email to sms allowed addresses_


        ### Parameters


        | Parameter | In | Type | Required | Description |

        | --- | --- | --- | --- | --- |

        | page | query | integer(int32) | false | [Page number](/#pagination) |

        | limit | query | integer(int32) | false | [Number of records per
        page](/#pagination) |



        Refer to [Status Codes](/#status-codes) for definitions of HTTP status
        code responses.



        <div style="background-color: #FF6A4B; padding: 10px; border-radius:
        8px;">
          <span style="color: white;">This endpoint requires authentication,</span> 
          <a href="/#authentication" style="color: white; text-decoration: underline;">more info...</a>
        </div>
      security:
        - basicAuth: []
      parameters:
        - name: Content-Type
          in: header
          schema:
            type: string
          example: application/json
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/view-allowed-emails'
      x-codeSamples:
        - lang: curl
          source: |-
            curl --include \
                 --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \

            'https://rest.clicksend.com/v3/sms/email-sms'
        - lang: PHP
          source: >-
            <?php

            require_once(__DIR__ . '/vendor/autoload.php');


            // Configure HTTP basic authorization: BasicAuth

            $config = ClickSend\Configuration::getDefaultConfiguration()
                          ->setUsername('USERNAME')
                          ->setPassword('API_KEY');

            $apiInstance = new ClickSend\Api\EmailToSmsApi(new
            GuzzleHttp\Client(),$config);

            $page = 1; // int | Page number

            $limit = 10; // int | Number of records per page


            try {
                $result = $apiInstance->smsEmailSmsGet($page, $limit);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling EmailToSmsApi->smsEmailSmsGet: ', $e->getMessage(), PHP_EOL;
            }

            ?>
        - lang: C#
          source: |-
            using IO.ClickSend.ClickSend.Api;
            using IO.ClickSend.Client;
            using IO.ClickSend.ClickSend.Model;

            var configuration = new Configuration()
            {
                Username = USERNAME, 
                Password = API_KEY  
            };
            var emailToSmsApi = new EmailToSmsApi(configuration);
            var response = emailToSmsApi.SmsEmailSmsGet();
        - lang: Java
          source: |-
            package ClickSend;

            import ClickSend.Api.EmailToSmsApi;

            public class view_allowed_email {
              public static void main(String[] args) {
                ApiClient defaultClient = new ApiClient();
                defaultClient.setUsername("USERNAME");
                defaultClient.setPassword("API_KEY");
                EmailToSmsApi apiInstance = new EmailToSmsApi(defaultClient);
                Integer page = 1; // Integer | Page number
                Integer limit = 10; // Integer | Number of records per page
                try {
                    String result = apiInstance.smsEmailSmsGet(page, limit);
                    System.out.println(result);
                } catch (ApiException e) {
                    System.err.println("Exception when calling EmailToSmsApi#smsEmailSmsGet");
                    e.printStackTrace();
                }
              }
            }
        - lang: Node.js
          source: |-
            var api = require('./api.js');

            var emailToSmsApi = new api.EmailToSmsApi("USERNAME", "API_KEY");

            var page = 1;
            var limit = 10;

            emailToSmsApi.smsEmailSmsGet(page, limit).then(function(response) {
              console.log(response.body);
            }).catch(function(err){
              console.error(err.body);
            });
        - lang: Ruby
          source: |-
            # load the gem
            require 'clicksend_client'
            require 'json'

            # setup authorization
            ClickSendClient.configure do |config|
              # Configure HTTP basic authorization: BasicAuth
              config.username = 'USERNAME'
              config.password = 'API_KEY'
            end

            api_instance = ClickSendClient::EmailToSmsApi.new

            opts = {
              page: 1,  # Integer | Page number
              limit: 10 # Integer | Number of records per page
            }

            begin
              # Get list of email to sms allowed addresses
              result = api_instance.sms_email_sms_get(opts)
              p JSON.parse(result)
            rescue ClickSendClient::ApiError => e
              puts "Exception when calling EmailToSmsApi->sms_email_sms_get: #{e.response_body}"
            end
        - lang: Python
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            page = 1 # int | Page number (optional) (default to 1)

            limit = 10 # int | Number of records per page (optional) (default to
            10)


            try:
                # Get list of email to sms allowed addresses
                api_response = api_instance.sms_email_sms_get(page=page, limit=limit)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_get: %s\n" % e)
        - lang: perl
          source: >-
            use WWW::ClickSendClient::EmailToSmsApi;


            my $username = 'YOUR_API_USER_NAME';

            my $password = 'YOUR_API_PASSWORD';


            my $api = WWW::ClickSendClient::EmailToSmsApi->new(username =>
            $username, password => $password);


            my $json_output = $api->sms_email_sms_get('page' => '1' ,'limit' =>
            '1');


            print $json_output;
        - lang: objc
          source: >-
            #import "CSDefaultConfiguration.h"

            #import "CSEmailToSmsApi.h"


            CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration
            sharedConfig];

            [apiConfig setUsername:@"USERNAME"];

            [apiConfig setPassword:@"PASSWORD"];


            CSEmailToSmsApi *emailToSmsApi = [[CSEmailToSmsApi alloc] init];

            NSNumber *page = [[NSNumber alloc] initWithInt:1];

            NSNumber *limit = [[NSNumber alloc] initWithInt:15];


            [emailToSmsApi smsEmailSmsGetWithPage:page limit:limit
            completionHandler:^(NSString *output, NSError *error) {
                  if (error) {
                       NSLog(@"Error: %@", error);
                  } else {
                       NSLog(@"%@", output);
                  }
            }];
        - lang: swift
          source: >-
            import Alamofire


            if let authHeader = Request.authorizationHeader(user: "USERNAME",
            password: "PASSWORD") {
                ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
            }


            EmailToSmsAPI.smsEmailSmsGet { (dataString, error) in
                guard let dataString = dataString else {
                    print(error!)
                    return
                }

                if let data = dataString.data(using: String.Encoding.utf8) {
                    do {
                        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                            print(dictonary)
                        } else {
                            print("Cannot convert the String value to JSON")
                            }
                    } catch let error as NSError {
                        print(error)
                    }
                }
            }
    post:
      summary: Add Allowed Email
      operationId: add-allowed-email
      description: >-
        _Create email to sms allowed address_


        ### Properties


        | Name | Type | Required | Restrictions | Description |

        | --- | --- | --- | --- | --- |

        | email_address | string | true | none | Your email address |

        | from | string | false |
        [yes](http://help.clicksend.com/SMS/what-is-a-sender-id-or-sender-number)
        | Your sender id |



        Refer to [Status Codes](/#status-codes) for definitions of HTTP status
        code responses.



        <div style="background-color: #FF6A4B; padding: 10px; border-radius:
        8px;">
          <span style="color: white;">This endpoint requires authentication,</span> 
          <a href="/#authentication" style="color: white; text-decoration: underline;">more info...</a>
        </div>
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                email_address:
                  type: string
                from:
                  type: string
                from_fax:
                  type: string
                subaccount_id:
                  type: string
              example:
                email_address: test@test.com
                from: test
                from_fax: '0411111111'
                subaccount_id: '{{subaccountId}}'
      security:
        - basicAuth: []
      parameters:
        - name: Content-Type
          in: header
          schema:
            type: string
          example: application/json
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/add-allowed-email'
      x-codeSamples:
        - lang: curl
          source: |-
            curl --include \
                 --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
                 --request POST \
                 --header "Content-Type: application/json" \

                 --data-binary "    {
                    \"email_address\":\"Cv3p0@gmail.com\",
                    \"from\":\"+17128845887\"
                }" \
            'https://rest.clicksend.com/v3/sms/email-sms'
        - lang: PHP
          source: >-
            <?php

            require_once(__DIR__ . '/vendor/autoload.php');


            // Configure HTTP basic authorization: BasicAuth

            $config = ClickSend\Configuration::getDefaultConfiguration()
                          ->setUsername('USERNAME')
                          ->setPassword('API_KEY');

            $apiInstance = new ClickSend\Api\EmailToSmsApi(new
            GuzzleHttp\Client(), $config);

            // \ClickSend\Model\EmailSMSAddress | EmailSMSAddress model

            $email_sms_address = new \ClickSend\Model\EmailSMSAddress();

            $email_sms_address->setEmailAddress("xxx@gmail.com");

            $email_sms_address->setFrom("+17128845887");

            $email_sms_address->setSubaccountId("74275");


            try {
                $result = $apiInstance->smsEmailSmsPost($email_sms_address);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling EmailToSmsApi->smsEmailSmsPost: ', $e->getMessage(), PHP_EOL;
            }

            ?>
        - lang: C#
          source: |-
            using IO.ClickSend.ClickSend.Api;
            using IO.ClickSend.Client;
            using IO.ClickSend.ClickSend.Model;

            var configuration = new Configuration()
            {
                Username = USERNAME, 
                Password = API_KEY  
            };
            var emailToSmsApi = new EmailToSmsApi(configuration);
            var response = emailToSmsApi.SmsEmailSmsPost(new EmailSMSAddress(
                emailAddress: "john@doe.com",
                from: "+11231231234",
                subaccountId: "SUB_ACCOUNT_ID
            ));
        - lang: Java
          source: |-
            package ClickSend;

            import ClickSend.Api.EmailToSmsApi;
            import ClickSend.Model.EmailSMSAddress;

            public class add_allowed_email {
              public static void main(String[] args) {
                ApiClient defaultClient = new ApiClient();
                defaultClient.setUsername("USERNAME");
                defaultClient.setPassword("API_KEY");
                EmailToSmsApi apiInstance = new EmailToSmsApi(defaultClient);
                // EmailSMSAddress | EmailSMSAddress model
                EmailSMSAddress emailSmsAddress = new EmailSMSAddress();
                emailSmsAddress.emailAddress("xxx@gmail.com");
                emailSmsAddress.from("+17128845887");
                emailSmsAddress.subaccountId("74275");
                try {
                    String result = apiInstance.smsEmailSmsPost(emailSmsAddress);
                    System.out.println(result);
                } catch (ApiException e) {
                    System.err.println("Exception when calling EmailToSmsApi#smsEmailSmsPost");
                    e.printStackTrace();
                }
              }
            }
        - lang: Node.js
          source: >-
            var api = require('./api.js');


            var emailToSmsApi = new api.EmailToSmsApi("USERNAME", "API_KEY");


            var emailSmsAddress = new api.EmailSMSAddress();


            emailSmsAddress.emailAddress = "xxx@gmail.com";

            emailSmsAddress.from = "+17128845887";

            emailSmsAddress.subaccountId = "74275";


            emailToSmsApi.smsEmailSmsPost(emailSmsAddress).then(function(response)
            {
              console.log(response.body);
            }).catch(function(err){
              console.error(err.body);
            });
        - lang: Ruby
          source: |-
            # load the gem
            require 'clicksend_client'
            require 'json'

            # setup authorization
            ClickSendClient.configure do |config|
              # Configure HTTP basic authorization: BasicAuth
              config.username = 'USERNAME'
              config.password = 'API_KEY'
            end

            api_instance = ClickSendClient::EmailToSmsApi.new

            # EmailSMSAddress | EmailSMSAddress model
            email_sms_address = ClickSendClient::EmailSMSAddress.new(
              "email_address": "test1@test.com",
              "from": "from",
              "subaccount_id": 0
            )

            begin
              # Create email to sms allowed address
              result = api_instance.sms_email_sms_post(email_sms_address)
              p JSON.parse(result)
            rescue ClickSendClient::ApiError => e
              puts "Exception when calling EmailToSmsApi->sms_email_sms_post: #{e.response_body}"
            end
        - lang: Python
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            # EmailSMSAddress | EmailSMSAddress model

            email_sms_address = clicksend_client.EmailSMSAddress(
                                email_address="Cv3p0@gmail.com",
                                _from="+17128845887",
                                subaccount_id=74275) 

            try:
                # Create email to sms allowed address
                api_response = api_instance.sms_email_sms_post(email_sms_address)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_post: %s\n" % e)
        - lang: perl
          source: >-
            use WWW::ClickSendClient::EmailToSmsApi;

            use WWW::ClickSendClient::Object::EmailSMSAddress;


            my $username = 'YOUR_API_USER_NAME';

            my $password = 'YOUR_API_PASSWORD';


            my $api = WWW::ClickSendClient::EmailToSmsApi->new(username =>
            $username, password => $password);


            my %params = (
                'email_address' => 'test1@test.com',
                'from'          => '+61411111111',
                'subaccount_id' => '1234',
            );


            my $email_obj = 
            WWW::ClickSendClient::Object::EmailSMSAddress->new(%params);


            my $json_output = $api->sms_email_sms_post('email_sms_address' => 
            $email_obj);


            print $json_output;
        - lang: objc
          source: >-
            #import "CSDefaultConfiguration.h"

            #import "CSEmailToSmsApi.h"



            CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration
            sharedConfig];

            [apiConfig setUsername:@"USERNAME"];

            [apiConfig setPassword:@"PASSWORD"];


            CSEmailToSmsApi *emailToSmsApi = [[CSEmailToSmsApi alloc] init];

            CSEmailSMSAddress *emailSmsAddress = [[CSEmailSMSAddress alloc]
            init];


            [emailToSmsApi smsEmailSmsPostWithEmailSmsAddress:emailSmsAddress
            completionHandler:^(NSString *output, NSError *error) {

                if (error) {
                       NSLog(@"Error: %@", error);
                } else {
                        NSLog(@"%@", output);
                }
            }];
        - lang: swift
          source: >-
            import Alamofire


            if let authHeader = Request.authorizationHeader(user: "USERNAME",
            password: "PASSWORD") {
                ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
            }


            let emailSmsAddr = EmailSMSAddress(emailAddress:
            "johndoe@email.com", from: "+17128845887", subaccountId: nil)


            EmailToSmsAPI.smsEmailSmsPost(emailSmsAddress: emailSmsAddr) {
            (dataString, error) in
                guard let dataString = dataString else {
                    print(error!)
                    return
                }

                if let data = dataString.data(using: String.Encoding.utf8) {
                    do {
                        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                            print(dictonary)
                         } else {
                            print("Cannot convert the String value to JSON")
                        }
                    } catch let error as NSError {
                            print(error)
                     }
                 }
            }
  /v3/sms/email-sms-stripped-strings:
    get:
      summary: View Stripped String Rules
      operationId: view-stripped-string-rules
      description: >-
        _Get list of email to sms stripped string rules_


        Get list of email to sms stripped string rules


        ### Parameters


        | Parameter | In | Type | Required | Description |

        | --- | --- | --- | --- | --- |

        | page | query | integer(int32) | false | Page number |

        | limit | query | integer(int32) | false | Number of records per page |



        Refer to [Status Codes](/#status-codes) for definitions of HTTP status
        code responses.



        <div style="background-color: #FF6A4B; padding: 10px; border-radius:
        8px;">
          <span style="color: white;">This endpoint requires authentication,</span> 
          <a href="/#authentication" style="color: white; text-decoration: underline;">more info...</a>
        </div>
      security:
        - basicAuth: []
      parameters:
        - name: Content-Type
          in: header
          schema:
            type: string
          example: application/json
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/view-stripped-string-rules'
      x-codeSamples:
        - lang: curl
          source: |-
            curl --include \
                 --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
            'https://rest.clicksend.com/v3/sms/email-sms-stripped-strings'
        - lang: PHP
          source: >-
            <?php

            require_once(__DIR__ . '/vendor/autoload.php');


            // Configure HTTP basic authorization: BasicAuth

            $config = ClickSend\Configuration::getDefaultConfiguration()
                          ->setUsername('USERNAME')
                          ->setPassword('API_KEY');

            $apiInstance = new ClickSend\Api\EmailToSmsApi(new
            GuzzleHttp\Client(),$config);

            $page = 1; // int | Page number

            $limit = 10; // int | Number of records per page


            try {
                $result = $apiInstance->smsEmailSmsStrippedStringsGet($page, $limit);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling EmailToSmsApi->smsEmailSmsStrippedStringsGet: ', $e->getMessage(), PHP_EOL;
            }

            ?>
        - lang: C#
          source: |-
            using IO.ClickSend.ClickSend.Api;
            using IO.ClickSend.Client;
            using IO.ClickSend.ClickSend.Model;

            var configuration = new Configuration()
            {
                Username = USERNAME, 
                Password = API_KEY  
            };
            var emailToSmsApi = new EmailToSmsApi(configuration);
            var response = emailToSmsApi.SmsEmailSmsStrippedStringsGet();
        - lang: Java
          source: |-
            package ClickSend;

            import ClickSend.Api.EmailToSmsApi;

            public class view_all_stripped_string_rule {
              public static void main(String[] args) {
                ApiClient defaultClient = new ApiClient();
                defaultClient.setUsername("USERNAME");
                defaultClient.setPassword("API_KEY");
                EmailToSmsApi apiInstance = new EmailToSmsApi(defaultClient);
                Integer page = 1; // Integer | Page number
                Integer limit = 10; // Integer | Number of records per page
                try {
                    String result = apiInstance.smsEmailSmsStrippedStringsGet(page, limit);
                    System.out.println(result);
                } catch (ApiException e) {
                    System.err.println("Exception when calling EmailToSmsApi#smsEmailSmsStrippedStringsGet");
                    e.printStackTrace();
                }
              }
            }
        - lang: Node.js
          source: >-
            var api = require('./api.js');


            var emailToSmsApi = new api.EmailToSmsApi("USERNAME", "API_KEY");


            var page = 1;

            var limit = 10;


            emailToSmsApi.smsEmailSmsStrippedStringsGet(page,
            limit).then(function(response) {
              console.log(response.body);
            }).catch(function(err){
              console.error(err.body);
            });
        - lang: Ruby
          source: |-
            # load the gem
            require 'clicksend_client'
            require 'json'

            # setup authorization
            ClickSendClient.configure do |config|
              # Configure HTTP basic authorization: BasicAuth
              config.username = 'USERNAME'
              config.password = 'API_KEY'
            end

            api_instance = ClickSendClient::EmailToSmsApi.new

            opts = {
              page: 1,  # Integer | Page number
              limit: 10 # Integer | Number of records per page
            }

            begin
              # Get list of email to sms stripped string rules
              result = api_instance.sms_email_sms_stripped_strings_get(opts)
              p JSON.parse(result)
            rescue ClickSendClient::ApiError => e
              puts "Exception when calling EmailToSmsApi->sms_email_sms_stripped_strings_get: #{e.response_body}"
            end
        - lang: Python
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            page = 1 # int | Page number (optional) (default to 1)

            limit = 10 # int | Number of records per page (optional) (default to
            10)


            try:
                # Get list of email to sms stripped string rules
                api_response = api_instance.sms_email_sms_stripped_strings_get(page=page, limit=limit)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_stripped_strings_get: %s\n" % e)
        - lang: perl
          source: >-
            use WWW::ClickSendClient::EmailToSmsApi;


            my $username = 'YOUR_API_USER_NAME';

            my $password = 'YOUR_API_PASSWORD';


            my $api = WWW::ClickSendClient::EmailToSmsApi->new(username =>
            $username, password => $password);


            my $json_output = $api->sms_email_sms_stripped_strings_get('page'
            =>  '1','limit' => '10');


            print $json_output;
        - lang: objc
          source: >-
            #import "CSDefaultConfiguration.h"

            #import "CSEmailToSmsApi.h"


            CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration
            sharedConfig];

            [apiConfig setUsername:@"USERNAME"];

            [apiConfig setPassword:@"PASSWORD"];


            CSEmailToSmsApi *emailToSmsApi = [[CSEmailToSmsApi alloc] init];

            NSNumber *page = [[NSNumber alloc] initWithInt:1];

            NSNumber *limit = [[NSNumber alloc] initWithInt:15];


            [emailToSmsApi smsEmailSmsStrippedStringsGetWithPage:page
            limit:limit completionHandler:^(NSString *output, NSError *error) {
                        if (error) {
                            NSLog(@"Error: %@", error);
                        } else {
                            NSLog(@"%@", output);
                        }
            }];
        - lang: swift
          source: >-
            import Alamofire


            if let authHeader = Request.authorizationHeader(user: "USERNAME",
            password: "PASWWORD") {
                ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
            }


            EmailToSmsAPI.smsEmailSmsStrippedStringsGet { (dataString, error) in
                guard let dataString = dataString else {
                    print(error!)
                    return
                }

                if let data = dataString.data(using: String.Encoding.utf8) {
                    do {
                        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                            print(dictonary)
                        } else {
                            print("Cannot convert the String value to JSON")
                        }
                    } catch let error as NSError {
                            print(error)
                    }
                }
            }
    post:
      summary: Create Stripped String Rule
      operationId: create-stripped-string-rule
      description: >-
        _Create email to sms stripped string rule_


        Create email to sms stripped string rules


        ### Parameters


        | Parameter | In | Type | Required | Description |

        | --- | --- | --- | --- | --- |

        | stripped-string | body | string | true | String to be stripped. |


        Refer to [Status Codes](/#status-codes) for definitions of HTTP status
        code responses.


        <div style="background-color: #FF6A4B; padding: 10px; border-radius:
        8px;">
          <span style="color: white;">This endpoint requires authentication,</span> 
          <a href="/#authentication" style="color: white; text-decoration: underline;">more info...</a>
        </div>
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                strip_string:
                  type: string
              example:
                strip_string: test
      security:
        - basicAuth: []
      parameters:
        - name: Content-Type
          in: header
          schema:
            type: string
          example: application/json
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/create-stripped-string-rule'
      x-codeSamples:
        - lang: curl
          source: |-
            curl --include \
                 --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
                 --request POST \
                 --header "Content-Type: application/json" \
                 --data-binary "{
                \"strip_string\" : \"~~~test~~~\"
            }" \
            'https://rest.clicksend.com/v3/sms/email-sms-stripped-strings'
        - lang: PHP
          source: >-
            <?php

            require_once(__DIR__ . '/vendor/autoload.php');


            // Configure HTTP basic authorization: BasicAuth

            $config = ClickSend\Configuration::getDefaultConfiguration()
                          ->setUsername('USERNAME')
                          ->setPassword('API_KEY');

            $apiInstance = new ClickSend\Api\EmailToSmsApi(new
            GuzzleHttp\Client(),$config);

            // \ClickSend\Model\StrippedString | StrippedString model

            $stripped_string = new \ClickSend\Model\StrippedString(); 

            $stripped_string->setStripString("  xxx  ");


            try {
                $result = $apiInstance->smsEmailSmsStrippedStringPost($stripped_string);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling EmailToSmsApi->smsEmailSmsStrippedStringPost: ', $e->getMessage(), PHP_EOL;
            }

            ?>
        - lang: C#
          source: >-
            using IO.ClickSend.ClickSend.Api;

            using IO.ClickSend.Client;

            using IO.ClickSend.ClickSend.Model;


            var configuration = new Configuration()

            {
                Username = USERNAME, 
                Password = API_KEY  
            };

            var emailToSmsApi = new EmailToSmsApi(configuration);

            var response = emailToSmsApi.SmsEmailSmsStrippedStringPost(new
            StrippedString("string"));
        - lang: Java
          source: |-
            package ClickSend;

            import ClickSend.Api.EmailToSmsApi;
            import ClickSend.Model.StrippedString;

            public class create_stripped_string_rule {
              public static void main(String[] args) {
                ApiClient defaultClient = new ApiClient();
                defaultClient.setUsername("USERNAME");
                defaultClient.setPassword("API_KEY");
                EmailToSmsApi apiInstance = new EmailToSmsApi(defaultClient);
                // StrippedString | StrippedString model
                StrippedString strippedString = new StrippedString(); 
                strippedString.stripString("  test  ");
                try {
                    String result = apiInstance.smsEmailSmsStrippedStringPost(strippedString);
                    System.out.println(result);
                } catch (ApiException e) {
                    System.err.println("Exception when calling EmailToSmsApi#smsEmailSmsStrippedStringPost");
                    e.printStackTrace();
                }
              }
            }
        - lang: Node.js
          source: >-
            var api = require('./api.js');


            var emailToSmsApi = new api.EmailToSmsApi("USERNAME", "API_KEY");


            var strippedString = new api.StrippedString();


            strippedString.stripString = "  test  "


            emailToSmsApi.smsEmailSmsStrippedStringPost(strippedString).then(function(response)
            {
              console.log(response.body);
            }).catch(function(err){
              console.error(err.body);
            });
        - lang: Ruby
          source: |-
            # load the gem
            require 'clicksend_client'
            require 'json'

            # setup authorization
            ClickSendClient.configure do |config|
              # Configure HTTP basic authorization: BasicAuth
              config.username = 'USERNAME'
              config.password = 'API_KEY'
            end

            api_instance = ClickSendClient::EmailToSmsApi.new

            # StrippedString | StrippedString model
            stripped_string = ClickSendClient::StrippedString.new(
              "strip_string": "~~~~test~~~~"
            )

            begin
              # Create email to sms stripped string rule
              result = api_instance.sms_email_sms_stripped_string_post(stripped_string)
              p JSON.parse(result)
            rescue ClickSendClient::ApiError => e
              puts "Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_post: #{e.response_body}"
            end
        - lang: Python
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            stripped_string = clicksend_client.StrippedString(strip_string= ' 
            test  ') # StrippedString | StrippedString model


            try:
                # Create email to sms stripped string rule
                api_response = api_instance.sms_email_sms_stripped_string_post(stripped_string)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_post: %s\n" % e)
        - lang: perl
          source: >-
            use WWW::ClickSendClient::EmailToSmsApi;


            my $username = 'YOUR_API_USER_NAME';

            my $password = 'YOUR_API_PASSWORD';


            my $api = WWW::ClickSendClient::EmailToSmsApi->new(username =>
            $username, password => $password);


            my $json_output =
            $api->sms_email_sms_stripped_string_post('strip_string' => 
            'XXXXXXXXX');


            print $json_output;
        - lang: objc
          source: >-
            #import "CSDefaultConfiguration.h"

            #import "CSEmailToSmsApi.h"



            CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration
            sharedConfig];

            [apiConfig setUsername:@"USERNAME"];

            [apiConfig setPassword:@"PASSWORD"];



            CSStrippedString *strippedString = [[CSStrippedString alloc] init];

            strippedString.stripString = @"string";


            CSEmailToSmsApi *emailToSmsApiInstance = [[CSEmailToSmsApi alloc]
            init];

            [emailToSmsApiInstance
            smsEmailSmsStrippedStringPostWithStrippedString:strippedString
            completionHandler:^(NSString *output, NSError *error) {
                        if (error) {
                            NSLog(@"Error: %@", error);
                        } else {
                            NSLog(@"%@", output);
                        }
            }];
        - lang: swift
          source: >-
            import Alamofire


            if let authHeader = Request.authorizationHeader(user: "USERNAME",
            password: "PASSWORD") {
                ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
            }


            let stripedString = StrippedString(stripString: "string")


            EmailToSmsAPI.smsEmailSmsStrippedStringPost(strippedString:
            stripedString) { (dataString, error) in
                guard let dataString = dataString else {
                    print(error!)
                    return
                }

                if let data = dataString.data(using: String.Encoding.utf8) {
                    do {
                        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                            print(dictonary)
                        } else {
                            print("bad json")
                        }
                    } catch let error as NSError {
                        print(error)
                    }
                }
            }
  /v3/sms/email-sms-stripped-strings/{rule_id}:
    get:
      summary: View Stripped String Rule
      operationId: view-stripped-string-rule
      description: >-
        _Get email to sms stripped string rule_


        Get email to sms stripped string rule


        ### Parameters


        | Parameter | In | Type | Required | Description |

        | --- | --- | --- | --- | --- |

        | rule_id | path | integer(int32) | true | Your rule id |



        Refer to [Status Codes](/#status-codes) for definitions of HTTP status
        code responses.



        <div style="background-color: #FF6A4B; padding: 10px; border-radius:
        8px;">
          <span style="color: white;">This endpoint requires authentication,</span> 
          <a href="/#authentication" style="color: white; text-decoration: underline;">more info...</a>
        </div>
      security:
        - basicAuth: []
      parameters:
        - name: Content-Type
          in: header
          schema:
            type: string
          example: application/json
        - name: rule_id
          in: path
          schema:
            type: string
          required: true
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/view-stripped-string-rule'
      x-codeSamples:
        - lang: curl
          source: >-
            curl --include \
                 --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
            'https://rest.clicksend.com/v3/sms/email-sms-stripped-strings/{rule_id}'
        - lang: PHP
          source: >-
            <?php

            require_once(__DIR__ . '/vendor/autoload.php');


            // Configure HTTP basic authorization: BasicAuth

            $config = ClickSend\Configuration::getDefaultConfiguration()
                          ->setUsername('USERNAME')
                          ->setPassword('API_KEY');

            $apiInstance = new ClickSend\Api\EmailToSmsApi(new
            GuzzleHttp\Client(),$config);

            $rule_id = 1137; // int | Your rule id


            try {
                $result = $apiInstance->smsEmailSmsStrippedStringGet($rule_id);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling EmailToSmsApi->smsEmailSmsStrippedStringGet: ', $e->getMessage(), PHP_EOL;
            }

            ?>
        - lang: C#
          source: |-
            using IO.ClickSend.ClickSend.Api;
            using IO.ClickSend.Client;
            using IO.ClickSend.ClickSend.Model;

            var configuration = new Configuration()
            {
                Username = USERNAME, 
                Password = API_KEY  
            };
            var emailToSmsApi = new EmailToSmsApi(configuration);
            var response = emailToSmsApi.SmsEmailSmsStrippedStringGet(RULE_ID);
        - lang: Java
          source: |-
            package ClickSend;

            import ClickSend.Api.EmailToSmsApi;

            public class view_specific_stripped_string_rule {
              public static void main(String[] args) {
                ApiClient defaultClient = new ApiClient();
                defaultClient.setUsername("USERNAME");
                defaultClient.setPassword("API_KEY");
                EmailToSmsApi apiInstance = new EmailToSmsApi(defaultClient);
                Integer ruleId = 1067; // Integer | Your rule id
                try {
                    String result = apiInstance.smsEmailSmsStrippedStringGet(ruleId);
                    System.out.println(result);
                } catch (ApiException e) {
                    System.err.println("Exception when calling EmailToSmsApi#smsEmailSmsStrippedStringGet");
                    e.printStackTrace();
                }
              }
            }
        - lang: Node.js
          source: >-
            var api = require('./api.js');


            var emailToSmsApi = new api.EmailToSmsApi("USERNAME", "API_KEY");


            var ruleId = 1119


            emailToSmsApi.smsEmailSmsStrippedStringGet(ruleId).then(function(response)
            {
              console.log(response.body);
            }).catch(function(err){
              console.error(err.body);
            });
        - lang: Ruby
          source: |-
            # load the gem
            require 'clicksend_client'
            require 'json'

            # setup authorization
            ClickSendClient.configure do |config|
              # Configure HTTP basic authorization: BasicAuth
              config.username = 'USERNAME'
              config.password = 'API_KEY'
            end

            api_instance = ClickSendClient::EmailToSmsApi.new

            rule_id = 56 # Integer | Your rule id

            begin
              # Get email to sms stripped string rule
              result = api_instance.sms_email_sms_stripped_string_get(rule_id)
              p JSON.parse(result)
            rescue ClickSendClient::ApiError => e
              puts "Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_get: #{e.response_body}"
            end
        - lang: Python
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            rule_id = 74275 # int | Your rule id


            try:
                # Get email to sms stripped string rule
                api_response = api_instance.sms_email_sms_stripped_string_get(rule_id)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_get: %s\n" % e)
        - lang: perl
          source: >-
            use WWW::ClickSendClient::EmailToSmsApi;


            my $username = 'YOUR_API_USER_NAME';

            my $password = 'YOUR_API_PASSWORD';


            my $api = WWW::ClickSendClient::EmailToSmsApi->new(username =>
            $username, password => $password);


            my $json_output = $api->sms_email_sms_stripped_string_get('rule_id'
            => '1234' );


            print $json_output;
        - lang: objc
          source: >-
            #import "CSDefaultConfiguration.h"

            #import "CSEmailToSmsApi.h"

             CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
            [apiConfig setUsername:@"USERNAME"];

            [apiConfig setPassword:@"PASSWORD"];


            CSEmailToSmsApi *emailToSmsApi = [[CSEmailToSmsApi alloc] init];

            NSNumber *RuleId = [[NSNumber alloc] initWithInt:1];


            [emailToSmsApi smsEmailSmsStrippedStringGetWithRuleId:RuleId
            completionHandler:^(NSString *output, NSError *error) {
                   if (error) {
                        NSLog(@"Error: %@", error);
                   } else {
                        NSLog(@"%@", output);
                   }
            }];
        - lang: swift
          source: >-
            import Alamofire


            if let authHeader = Request.authorizationHeader(user: "USERNAME",
            password: "PASSWORD") {
                ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
            }


            EmailToSmsAPI.smsEmailSmsStrippedStringGet(ruleId: 1) { (dataString,
            error) in
                guard let dataString = dataString else {
                    print(error!)
                    return
                }

                if let data = dataString.data(using: String.Encoding.utf8) {
                    do {
                        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                            print(dictonary)
                        } else {
                            print("bad json")
                        }
                    } catch let error as NSError {
                        print(error)
                    }
                }
            }
    put:
      summary: Update Stripped String Rule
      operationId: update-stripped-string-rule
      description: >-
        _Update email to sms stripped string rule_


        Update email to sms stripped string rule


        ### Parameters


        | Parameter | In | Type | Required | Description |

        | --- | --- | --- | --- | --- |

        | rule_id | path | integer(int32) | true | Your rule id |

        | stripped-string | body | string | true | String to be stripped. |



        Refer to [Status Codes](/#status-codes) for definitions of HTTP status
        code responses.



        <div style="background-color: #FF6A4B; padding: 10px; border-radius:
        8px;">
          <span style="color: white;">This endpoint requires authentication,</span> 
          <a href="/#authentication" style="color: white; text-decoration: underline;">more info...</a>
        </div>
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                strip_string:
                  type: string
              example:
                strip_string: test
      security:
        - basicAuth: []
      parameters:
        - name: Content-Type
          in: header
          schema:
            type: string
          example: application/json
        - name: rule_id
          in: path
          schema:
            type: string
          required: true
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/update-stripped-string-rule'
      x-codeSamples:
        - lang: curl
          source: >-
            curl --include \
                 --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
                 --request PUT \
                 --header "Content-Type: application/json" \
                 --data-binary "{
                \"strip_string\" : \"~~~test1~~~\"
            }" \

            'https://rest.clicksend.com/v3/sms/email-sms-stripped-strings/{rule_id}'
        - lang: PHP
          source: >-
            <?php

            require_once(__DIR__ . '/vendor/autoload.php');


            // Configure HTTP basic authorization: BasicAuth

            $config = ClickSend\Configuration::getDefaultConfiguration()
                          ->setUsername('USERNAME')
                          ->setPassword('API_KEY');

            $apiInstance = new ClickSend\Api\EmailToSmsApi(new
            GuzzleHttp\Client(),$config);

            // \ClickSend\Model\StrippedString | StrippedString model

            $stripped_string = new \ClickSend\Model\StrippedString(); 

            $stripped_string->setStripString("  xxx  ");

            $rule_id = 1137; // int | Your rule id


            try {
                $result = $apiInstance->smsEmailSmsStrippedStringPut($stripped_string, $rule_id);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling EmailToSmsApi->smsEmailSmsStrippedStringPut: ', $e->getMessage(), PHP_EOL;
            }

            ?>
        - lang: C#
          source: >-
            using IO.ClickSend.ClickSend.Api;

            using IO.ClickSend.Client;

            using IO.ClickSend.ClickSend.Model;


            var configuration = new Configuration()

            {
                Username = USERNAME, 
                Password = API_KEY  
            };

            var emailToSmsApi = new EmailToSmsApi(configuration);

            var response = emailToSmsApi.SmsEmailSmsStrippedStringPut(new
            StrippedString("NewString"), STRIPPED_STRING_ID);
        - lang: Java
          source: |-
            package ClickSend;

            import ClickSend.Api.EmailToSmsApi;
            import ClickSend.Model.StrippedString;

            public class update_stripped_string_rule {
              public static void main(String[] args) {
                ApiClient defaultClient = new ApiClient();
                defaultClient.setUsername("USERNAME");
                defaultClient.setPassword("API_KEY");
                EmailToSmsApi apiInstance = new EmailToSmsApi(defaultClient);
                // StrippedString | StrippedString model
                StrippedString strippedString = new StrippedString(); 
                strippedString.stripString("  test1  ");
                Integer ruleId = 1067; // Integer | Your rule id
                try {
                    String result = apiInstance.smsEmailSmsStrippedStringPut(strippedString, ruleId);
                    System.out.println(result);
                } catch (ApiException e) {
                    System.err.println("Exception when calling EmailToSmsApi#smsEmailSmsStrippedStringPut");
                    e.printStackTrace();
                }
              }
            }
        - lang: Node.js
          source: >-
            var api = require('./api.js');


            var emailToSmsApi = new api.EmailToSmsApi("USERNAME", "API_KEY");


            var strippedString = new api.StrippedString();


            strippedString.stripString = "  test  "


            var ruleId = 1119;


            emailToSmsApi.smsEmailSmsStrippedStringPut(strippedString,
            ruleId).then(function(response) {
              console.log(response.body);
            }).catch(function(err){
              console.error(err.body);
            });
        - lang: Ruby
          source: |-
            # load the gem
            require 'clicksend_client'
            require 'json'

            # setup authorization
            ClickSendClient.configure do |config|
              # Configure HTTP basic authorization: BasicAuth
              config.username = 'USERNAME'
              config.password = 'API_KEY'
            end

            api_instance = ClickSendClient::EmailToSmsApi.new

            # StrippedString | StrippedString model
            stripped_string = ClickSendClient::StrippedString.new(
              strip_string: "~~~test1~~~"
            )

            rule_id = 1066 # Integer | Your rule id

            begin
              # Update email to sms stripped string rule
              result = api_instance.sms_email_sms_stripped_string_put(stripped_string, rule_id)
              p JSON.parse(result)
            rescue ClickSendClient::ApiError => e
              puts "Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_put: #{e.response_body}"
            end
        - lang: Python
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            # StrippedString | StrippedString model

            stripped_string = clicksend_client.StrippedString(strip_string= ' 
            test1  ') 

            rule_id = 1055 # int | Your rule id


            try:
                # Update email to sms stripped string rule
                api_response = api_instance.sms_email_sms_stripped_string_put(stripped_string, rule_id)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_put: %s\n" % e)
        - lang: perl
          source: >-
            use WWW::ClickSendClient::EmailToSmsApi;


            my $username = 'YOUR_API_USER_NAME';

            my $password = 'YOUR_API_PASSWORD';


            my $api = WWW::ClickSendClient::EmailToSmsApi->new(username =>
            $username, password => $password);


            my $json_output = $api->sms_email_sms_stripped_string_put('rule_id'
            => '12345','strip_string' => 'xxxxxx');


            print $json_output;
        - lang: objc
          source: >-
            #import "CSDefaultConfiguration.h"

            #import "CSEmailToSmsApi.h"


            CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration
            sharedConfig];

            [apiConfig setUsername:@"USERNAME"];

            [apiConfig setPassword:@"PASSWORD"];


            NSNumber *ruleId = [[NSNumber alloc] initWithInt:1];

            CSStrippedString *strippedString = [[CSStrippedString alloc] init];

            strippedString.stripString = @"string";


            CSEmailToSmsApi *emailToSmsApiIntance = [[CSEmailToSmsApi alloc]
            init];

            [emailToSmsApiIntance
            smsEmailSmsStrippedStringPutWithStrippedString:strippedString
            ruleId:ruleId completionHandler:^(NSString *output, NSError *error)
            {
                  if (error) {
                      NSLog(@"Error: %@", error);
                  } else {
                       NSLog(@"%@", output);
                  }
            }];
        - lang: swift
          source: >-
            import Alamofire


            if let authHeader = Request.authorizationHeader(user: "USERNAME",
            password: "PASSWORD") {
                ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
            }


            let stripedString = StrippedString(stripString: "string")


            EmailToSmsAPI.smsEmailSmsStrippedStringPut(strippedString:
            stripedString, ruleId: 1) { (dataString, error) in
                guard let dataString = dataString else {
                    print(error!)
                    return
                }

                if let data = dataString.data(using: String.Encoding.utf8) {
                    do {
                        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                            print(dictonary)
                        } else {
                            print("bad json")
                        }
                    } catch let error as NSError {
                        print(error)
                    }
                }
            }
    delete:
      summary: Delete Stripped String Rule
      operationId: delete-stripped-string-rule
      description: >-
        _Delete email to sms stripped string rule_


        Delete email to sms stripped string rule


        ### Parameters


        | Parameter | In | Type | Required | Description |

        | --- | --- | --- | --- | --- |

        | rule_id | path | integer(int32) | true | Your rule id |



        Refer to [Status Codes](/#status-codes) for definitions of HTTP status
        code responses.



        <div style="background-color: #FF6A4B; padding: 10px; border-radius:
        8px;">
          <span style="color: white;">This endpoint requires authentication,</span> 
          <a href="/#authentication" style="color: white; text-decoration: underline;">more info...</a>
        </div>
      security:
        - basicAuth: []
      parameters:
        - name: Content-Type
          in: header
          schema:
            type: string
          example: application/json
        - name: rule_id
          in: path
          schema:
            type: string
          required: true
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/delete-stripped-string-rule'
      x-codeSamples:
        - lang: curl
          source: >-
            curl --include \
                 --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
                 --request DELETE \
            'https://rest.clicksend.com/v3/sms/email-sms-stripped-strings/{rule_id}'
        - lang: PHP
          source: >-
            <?php

            require_once(__DIR__ . '/vendor/autoload.php');


            // Configure HTTP basic authorization: BasicAuth

            $config = ClickSend\Configuration::getDefaultConfiguration()
                          ->setUsername('USERNAME')
                          ->setPassword('API_KEY');

            $apiInstance = new ClickSend\Api\EmailToSmsApi(new
            GuzzleHttp\Client(),$config);

            $rule_id = 1137; // int | Your rule id


            try {
                $result = $apiInstance->smsEmailSmsStrippedStringDelete($rule_id);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling EmailToSmsApi->smsEmailSmsStrippedStringDelete: ', $e->getMessage(), PHP_EOL;
            }

            ?>
        - lang: C#
          source: >-
            using IO.ClickSend.ClickSend.Api;

            using IO.ClickSend.Client;

            using IO.ClickSend.ClickSend.Model;


            var configuration = new Configuration()

            {
                Username = USERNAME, 
                Password = API_KEY  
            };

            var emailToSmsApi = new EmailToSmsApi(configuration);

            var response =
            emailToSmsApi.SmsEmailSmsStrippedStringDelete(RULE_ID);
        - lang: Java
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            rule_id = 56 # int | Your rule id


            try:
                # Delete email to sms stripped string rule
                api_response = api_instance.sms_email_sms_stripped_string_delete(rule_id)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_delete: %s\n" % e)
        - lang: Node.js
          source: >-
            var api = require('./api.js');


            var emailToSmsApi = new api.EmailToSmsApi("USERNAME", "API_KEY");


            var ruleId = 1119;


            emailToSmsApi.smsEmailSmsStrippedStringDelete(ruleId).then(function(response)
            {
              console.log(response.body);
            }).catch(function(err){
              console.error(err.body);
            });
        - lang: Ruby
          source: |-
            # load the gem
            require 'clicksend_client'
            require 'json'

            # setup authorization
            ClickSendClient.configure do |config|
              # Configure HTTP basic authorization: BasicAuth
              config.username = 'USERNAME'
              config.password = 'API_KEY'
            end

            api_instance = ClickSendClient::EmailToSmsApi.new

            rule_id = 56 # Integer | Your rule id

            begin
              # Delete email to sms stripped string rule
              result = api_instance.sms_email_sms_stripped_string_delete(rule_id)
              p JSON.parse(result)
            rescue ClickSendClient::ApiError => e
              puts "Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_delete: #{e.response_body}"
            end
        - lang: Python
          source: >-
            from __future__ import print_function

            import clicksend_client

            from clicksend_client.rest import ApiException


            # Configure HTTP basic authorization: BasicAuth

            configuration = clicksend_client.Configuration()

            configuration.username = 'USERNAME'

            configuration.password = 'API_KEY'


            # create an instance of the API class

            api_instance =
            clicksend_client.EmailToSmsApi(clicksend_client.ApiClient(configuration))

            rule_id = 56 # int | Your rule id


            try:
                # Delete email to sms stripped string rule
                api_response = api_instance.sms_email_sms_stripped_string_delete(rule_id)
                print(api_response)
            except ApiException as e:
                print("Exception when calling EmailToSmsApi->sms_email_sms_stripped_string_delete: %s\n" % e)
        - lang: perl
          source: >-
            use WWW::ClickSendClient::EmailToSmsApi;


            my $username = 'YOUR_API_USER_NAME';

            my $password = 'YOUR_API_PASSWORD';


            my $api = WWW::ClickSendClient::EmailToSmsApi->new(username =>
            $username, password => $password);


            my $json_output =
            $api->sms_email_sms_stripped_string_delete('rule_id' => '1234');


            print $json_output;
        - lang: objc
          source: >-
            #import "CSDefaultConfiguration.h"

            #import "CSEmailToSmsApi.h"



            CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration
            sharedConfig];

            [apiConfig setUsername:@"USERNAME"];

            [apiConfig setPassword:@"PASSWORD"];


            NSNumber *ruleid = [[NSNumber alloc] initWithInt:1];


            CSEmailToSmsApi *emailToSmsApi = [[CSEmailToSmsApi alloc] init];

            [emailToSmsApi smsEmailSmsStrippedStringDeleteWithRuleId:ruleid
            completionHandler:^(NSString *output, NSError *error) {
                   if (error) {
                        NSLog(@"Error: %@", error);
                    } else {
                         NSLog(@"%@", output);
                    }
            }];
        - lang: swift
          source: >-
            import Alamofire


            if let authHeader = Request.authorizationHeader(user: "USERNAME",
            password: "PASSWORD") {
                ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
            }


            EmailToSmsAPI.smsEmailSmsStrippedStringDelete(ruleId: 1) {
            (dataString, error) in
                guard let dataString = dataString else {
                    print(error!)
                    return
                }

                if let data = dataString.data(using: String.Encoding.utf8) {
                    do {
                        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                            print(dictonary)
                        } else {
                            print("bad json")
                        }
                    } catch let error as NSError {
                        print(error)
                    }
                }
            }
