sentdm 0.45.0 → 0.46.0

data/rbi/sentdm/models/channels/supplied_document.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class SuppliedDocument < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::SuppliedDocument, Sentdm::Internal::AnyHash)
+          end
+
+        # Identifier of the upload, for fetching it back through the documents endpoints.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :document_id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :file_name
+
+        # The catalog's name for this document, matching the requirement it satisfies.
+        sig { returns(T.nilable(String)) }
+        attr_reader :key
+
+        sig { params(key: String).void }
+        attr_writer :key
+
+        # A document a market asked for and has been given.
+        sig do
+          params(
+            document_id: T.nilable(String),
+            file_name: T.nilable(String),
+            key: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Identifier of the upload, for fetching it back through the documents endpoints.
+          document_id: nil,
+          file_name: nil,
+          # The catalog's name for this document, matching the requirement it satisfies.
+          key: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              document_id: T.nilable(String),
+              file_name: T.nilable(String),
+              key: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/whatsapp_channel.rbi

@@ -0,0 +1,172 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    WhatsappChannel = Channels::WhatsappChannel
+
+    module Channels
+      class WhatsappChannel < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::WhatsappChannel, Sentdm::Internal::AnyHash)
+          end
+
+        # Derived from the organization's shared-account listing, like SolutionId.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :owner_business_id
+
+        # The Meta phone-number id the profile sends from, or null when the account is
+        # connected but no number has been named yet — which is what a provisioning status
+        # means here.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_number_id
+
+        # A sentence for reason_code, saying what to do where it is yours. Omitted while
+        # ACTIVE.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        # Why the account is not ACTIVE, as a stable code: an ErrorCodes CHANNEL_xxx value
+        # such as CHANNEL_001 (something you owe) or CHANNEL_009 (under review). Switch on
+        # this rather than on reason. Omitted while ACTIVE. Read-only; when nothing more
+        # specific is known it is the generic reason for the status.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason_code
+
+        # Derived, not echoed. The request no longer accepts this — it is read off the
+        # organization's shared-account listing at connect time and reported back so a
+        # caller can see which partnership the account actually arrived through.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :solution_id
+
+        # Read-only. Never carries a token — the row holds that and it is not returned.
+        # ACTION_NEEDED when no account is connected or the account has no phone number:
+        # both are yours to do.
+        sig do
+          returns(
+            T.nilable(Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol)
+          )
+        end
+        attr_accessor :status
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :waba_id
+
+        # The profile's WhatsApp account. Its status is Meta's verification state.
+        sig do
+          params(
+            owner_business_id: T.nilable(String),
+            phone_number_id: T.nilable(String),
+            reason: T.nilable(String),
+            reason_code: T.nilable(String),
+            solution_id: T.nilable(String),
+            status:
+              T.nilable(Sentdm::Channels::WhatsappChannel::Status::OrSymbol),
+            waba_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Derived from the organization's shared-account listing, like SolutionId.
+          owner_business_id: nil,
+          # The Meta phone-number id the profile sends from, or null when the account is
+          # connected but no number has been named yet — which is what a provisioning status
+          # means here.
+          phone_number_id: nil,
+          # A sentence for reason_code, saying what to do where it is yours. Omitted while
+          # ACTIVE.
+          reason: nil,
+          # Why the account is not ACTIVE, as a stable code: an ErrorCodes CHANNEL_xxx value
+          # such as CHANNEL_001 (something you owe) or CHANNEL_009 (under review). Switch on
+          # this rather than on reason. Omitted while ACTIVE. Read-only; when nothing more
+          # specific is known it is the generic reason for the status.
+          reason_code: nil,
+          # Derived, not echoed. The request no longer accepts this — it is read off the
+          # organization's shared-account listing at connect time and reported back so a
+          # caller can see which partnership the account actually arrived through.
+          solution_id: nil,
+          # Read-only. Never carries a token — the row holds that and it is not returned.
+          # ACTION_NEEDED when no account is connected or the account has no phone number:
+          # both are yours to do.
+          status: nil,
+          waba_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              owner_business_id: T.nilable(String),
+              phone_number_id: T.nilable(String),
+              reason: T.nilable(String),
+              reason_code: T.nilable(String),
+              solution_id: T.nilable(String),
+              status:
+                T.nilable(
+                  Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+                ),
+              waba_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Read-only. Never carries a token — the row holds that and it is not returned.
+        # ACTION_NEEDED when no account is connected or the account has no phone number:
+        # both are yours to do.
+        module Status
+          extend Sentdm::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Sentdm::Channels::WhatsappChannel::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # We are working on it and there is nothing for you to do — a number is being procured, or a registration is being assembled. Minutes to hours.
+          PROVISIONING =
+            T.let(
+              :PROVISIONING,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # **Waiting on you.** Something the market asks for has not been supplied, a regulator rejected what was, or we have asked you to correct and resubmit your identity data. Nothing progresses until you act. For an SMS market, `GET /v3/channels/sms/{country}/{type}` names what it wants and `PATCH` on the same path supplies it — compliance values, documents and numbers alike.
+          ACTION_NEEDED =
+            T.let(
+              :ACTION_NEEDED,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # With a regulator or carrier — filed, or assembled and queued for us to file — and their answer is what moves it, to `ACTIVE` or back to `ACTION_NEEDED`. Nothing on your side changes it. Days for SMS, weeks for RCS.
+          PENDING_REVIEW =
+            T.let(
+              :PENDING_REVIEW,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # Can carry traffic now. A channel a sender profile runs on its organization's reads `ACTIVE` too — it sends, which is what the field is about.
+          ACTIVE =
+            T.let(
+              :ACTIVE,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # **It had a working sender and no longer does** — the number was released, or the campaign it carried lapsed. Distinct from `PROVISIONING`, which means it has never sent yet: the same absence of a sender, opposite news. Sends will fail until it returns to `ACTIVE`.
+          INACTIVE =
+            T.let(
+              :INACTIVE,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/whatsapp_create_params.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class WhatsappCreateParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::WhatsappCreateParams,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The Meta phone-number id of the number on WabaId, which assigns it to this
+        # profile as the number it sends from. It is not checked against the account here,
+        # so name the account's number; it is refused if another profile already uses it.
+        #
+        # Optional: omit it to connect the account and settle the number later. Nothing
+        # picks one on your behalf.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_number_id
+
+        # Sandbox flag - when true, the operation is simulated without side effects Useful
+        # for testing integrations without actual execution
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :sandbox
+
+        sig { params(sandbox: T::Boolean).void }
+        attr_writer :sandbox
+
+        # WhatsApp Business Account id — one of the accounts shared into your
+        # organization. Required: the organization holds one per client, and nothing but
+        # the caller says which is meant here.
+        sig { returns(T.nilable(String)) }
+        attr_reader :waba_id
+
+        sig { params(waba_id: String).void }
+        attr_writer :waba_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_key
+
+        sig { params(idempotency_key: String).void }
+        attr_writer :idempotency_key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :x_profile_id
+
+        sig { params(x_profile_id: String).void }
+        attr_writer :x_profile_id
+
+        sig do
+          params(
+            phone_number_id: T.nilable(String),
+            sandbox: T::Boolean,
+            waba_id: String,
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The Meta phone-number id of the number on WabaId, which assigns it to this
+          # profile as the number it sends from. It is not checked against the account here,
+          # so name the account's number; it is refused if another profile already uses it.
+          #
+          # Optional: omit it to connect the account and settle the number later. Nothing
+          # picks one on your behalf.
+          phone_number_id: nil,
+          # Sandbox flag - when true, the operation is simulated without side effects Useful
+          # for testing integrations without actual execution
+          sandbox: nil,
+          # WhatsApp Business Account id — one of the accounts shared into your
+          # organization. Required: the organization holds one per client, and nothing but
+          # the caller says which is meant here.
+          waba_id: nil,
+          idempotency_key: nil,
+          x_profile_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              phone_number_id: T.nilable(String),
+              sandbox: T::Boolean,
+              waba_id: String,
+              idempotency_key: String,
+              x_profile_id: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels_state.rbi

@@ -0,0 +1,151 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ChannelsState < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::ChannelsState, Sentdm::Internal::AnyHash) }
+
+      # Which customer these channels belong to — the key's own, or the profile named in
+      # x-profile-id.
+      #
+      # Same reason the brand carries one: as the response to /v3/channels there is no
+      # other id in the document, and under x-profile-id this is the profile the call
+      # resolved to rather than the caller. Absent when nested inside a sender profile,
+      # whose own id already says whose they are.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_id
+
+      # The markets this profile can send MMS in, one entry per country, or empty when
+      # none.
+      #
+      # Appears alongside sms rather than replacing an entry in it: the two are separate
+      # senders on the same number and a caller needs to see both — a market can be live
+      # for SMS while its MMS row is still provisioning, or MMS-incapable entirely
+      # because the market's sender-type SKU does not carry it.
+      sig { returns(T.nilable(T::Array[Sentdm::MmsMarket])) }
+      attr_reader :mms
+
+      sig { params(mms: T::Array[Sentdm::MmsMarket::OrHash]).void }
+      attr_writer :mms
+
+      # An RCS agent as its owner sees it: the order form back, plus where the
+      # submission stands.
+      #
+      # Not RcsSenderResponse. That one is the admin projection and carries the pipeline
+      # we track about a customer's request — internalStatus, statusReason, isLaunched —
+      # and the S3 keys behind the assets. None of that is the customer's to read: an
+      # internal status is a note to ourselves, and an S3 key is a storage detail that
+      # would become a contract the moment it was published.
+      #
+      # What is here is what the caller sent, in the names it sent them under, plus the
+      # three things only we can answer: the record's id, its status, and the number it
+      # sends from. So a read after a write shows the form as stored rather than as
+      # echoed.
+      sig { returns(T.nilable(Sentdm::Channels::RcsAgent)) }
+      attr_reader :rcs
+
+      sig { params(rcs: T.nilable(Sentdm::Channels::RcsAgent::OrHash)).void }
+      attr_writer :rcs
+
+      sig { returns(T.nilable(T::Array[Sentdm::Channels::SMSMarket])) }
+      attr_reader :sms
+
+      sig { params(sms: T::Array[Sentdm::Channels::SMSMarket::OrHash]).void }
+      attr_writer :sms
+
+      # The numbers this profile carries phone calls on, one entry per number, or empty
+      # when none. Voice is per number like an SMS market is per country: each number is
+      # its own channel row, turned on and off on its own, and one of them is the line
+      # app-originated calls fall back to.
+      sig { returns(T.nilable(T::Array[Sentdm::Channels::VoiceNumber])) }
+      attr_reader :voice
+
+      sig do
+        params(voice: T::Array[Sentdm::Channels::VoiceNumber::OrHash]).void
+      end
+      attr_writer :voice
+
+      # The profile's WhatsApp account. Its status is Meta's verification state.
+      sig { returns(T.nilable(Sentdm::Channels::WhatsappChannel)) }
+      attr_reader :whatsapp
+
+      sig do
+        params(
+          whatsapp: T.nilable(Sentdm::Channels::WhatsappChannel::OrHash)
+        ).void
+      end
+      attr_writer :whatsapp
+
+      # The channels a profile sends on. SMS is a list because a profile can send in
+      # several markets; WhatsApp and RCS are single, because a profile has one business
+      # account and one agent.
+      sig do
+        params(
+          customer_id: T.nilable(String),
+          mms: T::Array[Sentdm::MmsMarket::OrHash],
+          rcs: T.nilable(Sentdm::Channels::RcsAgent::OrHash),
+          sms: T::Array[Sentdm::Channels::SMSMarket::OrHash],
+          voice: T::Array[Sentdm::Channels::VoiceNumber::OrHash],
+          whatsapp: T.nilable(Sentdm::Channels::WhatsappChannel::OrHash)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Which customer these channels belong to — the key's own, or the profile named in
+        # x-profile-id.
+        #
+        # Same reason the brand carries one: as the response to /v3/channels there is no
+        # other id in the document, and under x-profile-id this is the profile the call
+        # resolved to rather than the caller. Absent when nested inside a sender profile,
+        # whose own id already says whose they are.
+        customer_id: nil,
+        # The markets this profile can send MMS in, one entry per country, or empty when
+        # none.
+        #
+        # Appears alongside sms rather than replacing an entry in it: the two are separate
+        # senders on the same number and a caller needs to see both — a market can be live
+        # for SMS while its MMS row is still provisioning, or MMS-incapable entirely
+        # because the market's sender-type SKU does not carry it.
+        mms: nil,
+        # An RCS agent as its owner sees it: the order form back, plus where the
+        # submission stands.
+        #
+        # Not RcsSenderResponse. That one is the admin projection and carries the pipeline
+        # we track about a customer's request — internalStatus, statusReason, isLaunched —
+        # and the S3 keys behind the assets. None of that is the customer's to read: an
+        # internal status is a note to ourselves, and an S3 key is a storage detail that
+        # would become a contract the moment it was published.
+        #
+        # What is here is what the caller sent, in the names it sent them under, plus the
+        # three things only we can answer: the record's id, its status, and the number it
+        # sends from. So a read after a write shows the form as stored rather than as
+        # echoed.
+        rcs: nil,
+        sms: nil,
+        # The numbers this profile carries phone calls on, one entry per number, or empty
+        # when none. Voice is per number like an SMS market is per country: each number is
+        # its own channel row, turned on and off on its own, and one of them is the line
+        # app-originated calls fall back to.
+        voice: nil,
+        # The profile's WhatsApp account. Its status is Meta's verification state.
+        whatsapp: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            customer_id: T.nilable(String),
+            mms: T::Array[Sentdm::MmsMarket],
+            rcs: T.nilable(Sentdm::Channels::RcsAgent),
+            sms: T::Array[Sentdm::Channels::SMSMarket],
+            voice: T::Array[Sentdm::Channels::VoiceNumber],
+            whatsapp: T.nilable(Sentdm::Channels::WhatsappChannel)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/compliance_attachment_template.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ComplianceAttachmentTemplate < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ComplianceAttachmentTemplate, Sentdm::Internal::AnyHash)
+        end
+
+      # The multipart field name to attach the file under.
+      sig { returns(T.nilable(String)) }
+      attr_reader :field_name
+
+      sig { params(field_name: String).void }
+      attr_writer :field_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :label
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :required
+
+      sig { params(required: T::Boolean).void }
+      attr_writer :required
+
+      # A file this market wants, and the multipart field to send it as.
+      #
+      # Separate from compliance because a file is not JSON: the channel call accepts
+      # multipart, and each file is named after the key it satisfies. Listing documents
+      # among the JSON entries would describe a request nobody could send.
+      sig do
+        params(
+          field_name: String,
+          label: T.nilable(String),
+          required: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The multipart field name to attach the file under.
+        field_name: nil,
+        label: nil,
+        required: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { field_name: String, label: T.nilable(String), required: T::Boolean }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/compliance_requirement.rbi

@@ -0,0 +1,149 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ComplianceRequirement < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ComplianceRequirement, Sentdm::Internal::AnyHash)
+        end
+
+      # Refinement of type where the market demands a specific shape, e.g. e164, url,
+      # email, iso3166_alpha2, csv_keywords.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :format_
+
+      # Shape of each entry, when this requirement is a list of objects rather than of
+      # scalars.
+      #
+      # The compliance value stays null in the setup body like every other blank — a
+      # body that carries a half-filled object is one the endpoint refuses, which would
+      # break the promise that the published body can be sent as it stands. So the shape
+      # is described here instead, and each entry the caller composes has these keys.
+      sig { returns(T.nilable(T::Array[Sentdm::ComplianceRequirement])) }
+      attr_accessor :item_fields
+
+      # Key to use in the compliance map.
+      sig { returns(T.nilable(String)) }
+      attr_reader :key
+
+      sig { params(key: String).void }
+      attr_writer :key
+
+      # Human label, suitable for a form field.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :label
+
+      # Most entries this value accepts, where the market caps it.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :max_items
+
+      # Shortest acceptable value, where the market sets one. TCR refuses a consent
+      # narrative under 40 characters, and finding that out at submission time is the
+      # round trip this exists to save.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :min_length
+
+      # Why the market asks for this.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :notes
+
+      # Accepted values, when the type is an enum or a constrained array.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :options
+
+      # Whether the market always demands this value.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :required
+
+      sig { params(required: T::Boolean).void }
+      attr_writer :required
+
+      # Condition that makes this value required, when it is only required in some cases
+      # — e.g. brand.entity_type == PUBLIC_PROFIT. Evaluate it against your own payload
+      # to know whether to collect the field.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :required_when
+
+      # Value type: string, number, boolean, date, enum, object, array or document.
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      # One value a market expects in a channel call's compliance map.
+      sig do
+        params(
+          format_: T.nilable(String),
+          item_fields: T.nilable(T::Array[Sentdm::ComplianceRequirement]),
+          key: String,
+          label: T.nilable(String),
+          max_items: T.nilable(Integer),
+          min_length: T.nilable(Integer),
+          notes: T.nilable(String),
+          options: T.nilable(T::Array[String]),
+          required: T::Boolean,
+          required_when: T.nilable(String),
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Refinement of type where the market demands a specific shape, e.g. e164, url,
+        # email, iso3166_alpha2, csv_keywords.
+        format_: nil,
+        # Shape of each entry, when this requirement is a list of objects rather than of
+        # scalars.
+        #
+        # The compliance value stays null in the setup body like every other blank — a
+        # body that carries a half-filled object is one the endpoint refuses, which would
+        # break the promise that the published body can be sent as it stands. So the shape
+        # is described here instead, and each entry the caller composes has these keys.
+        item_fields: nil,
+        # Key to use in the compliance map.
+        key: nil,
+        # Human label, suitable for a form field.
+        label: nil,
+        # Most entries this value accepts, where the market caps it.
+        max_items: nil,
+        # Shortest acceptable value, where the market sets one. TCR refuses a consent
+        # narrative under 40 characters, and finding that out at submission time is the
+        # round trip this exists to save.
+        min_length: nil,
+        # Why the market asks for this.
+        notes: nil,
+        # Accepted values, when the type is an enum or a constrained array.
+        options: nil,
+        # Whether the market always demands this value.
+        required: nil,
+        # Condition that makes this value required, when it is only required in some cases
+        # — e.g. brand.entity_type == PUBLIC_PROFIT. Evaluate it against your own payload
+        # to know whether to collect the field.
+        required_when: nil,
+        # Value type: string, number, boolean, date, enum, object, array or document.
+        type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            format_: T.nilable(String),
+            item_fields: T.nilable(T::Array[Sentdm::ComplianceRequirement]),
+            key: String,
+            label: T.nilable(String),
+            max_items: T.nilable(Integer),
+            min_length: T.nilable(Integer),
+            notes: T.nilable(String),
+            options: T.nilable(T::Array[String]),
+            required: T::Boolean,
+            required_when: T.nilable(String),
+            type: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end