typecast-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 783ee042ba45a4a26659e61c50b2e28fb058f03ba0ad11e1573bf43a5abca44a
+  data.tar.gz: a15b17e6e707b5dc8bf4c524c6a3b50ceee8b0dcada0d34820359905f38042c9
+SHA512:
+  metadata.gz: 66ace71a958a4f2f05e321d9be6ff162f66e8fbf4c327bb300ff29f716a4b4e64d426cc9034fb830452a97689a2e28ad6143135d501c1e8f024d7d3ab6926c2a
+  data.tar.gz: 1145c85137b9fb6253b3db418c8f50ecd53afe244c98a8c6df3b867ed9dc94b24f49f34ee98707fd76f6dc8cbfa1c39ae84698ec31895dff619492731e2ae5f3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neosapience
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# Typecast Ruby SDK
+
+Official Ruby SDK for the Typecast Text-to-Speech API.
+
+## Installation
+
+```bash
+gem install typecast-ruby
+```
+
+For local development from this monorepo:
+
+```ruby
+gem "typecast-ruby", path: "../typecast-ruby"
+```
+
+## Quick Start
+
+```ruby
+require "typecast"
+
+client = Typecast::Client.new(api_key: ENV["TYPECAST_API_KEY"])
+response = client.text_to_speech(
+  Typecast::Models::TTSRequest.new(
+    voice_id: "tc_60e5426de8b95f1d3000d7b5",
+    text: "Hello from Typecast Ruby.",
+    model: Typecast::Models::TTS_MODEL_V30,
+    language: "eng",
+    output: Typecast::Models::Output.new(audio_format: "wav")
+  )
+)
+
+File.binwrite("hello.wav", response.audio_data)
+```
+
+## Features
+
+- Text-to-speech synthesis
+- Streaming synthesis
+- Word and character timestamps with SRT/VTT helpers
+- Voice listing and subscription APIs
+- Instant voice cloning
+- No runtime dependencies beyond the Ruby standard library
+
+## Testing
+
+```bash
+make install
+make test
+TYPECAST_API_KEY=... make e2e
+```

data/THIRD-PARTY-LICENSES.md

@@ -0,0 +1,13 @@
+# Third-Party Licenses
+
+The Ruby SDK has no runtime gem dependencies.
+
+Development and test dependencies:
+
+| Dependency | Usage | License |
+| --- | --- | --- |
+| minitest | Unit tests | MIT |
+| rake | Test and coverage tasks | MIT |
+
+This summary is based on the dependencies declared in `Gemfile` and
+`typecast-ruby.gemspec`.

data/lib/typecast/client.rb

@@ -0,0 +1,209 @@
+require "json"
+require "net/http"
+require "securerandom"
+require "uri"
+
+require "typecast/errors"
+require "typecast/models"
+require "typecast/timestamps"
+
+module Typecast
+  class Client
+    DEFAULT_BASE_URL = "https://api.typecast.ai".freeze
+
+    attr_reader :api_key, :base_url
+
+    def initialize(api_key: ENV["TYPECAST_API_KEY"], base_url: ENV["TYPECAST_API_HOST"] || DEFAULT_BASE_URL, open_timeout: 10, read_timeout: 30)
+      @api_key = api_key.to_s
+      @base_url = normalize_base_url(base_url)
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+    end
+
+    def text_to_speech(request)
+      response = request_json(:post, "/v1/text-to-speech", request.to_h)
+      Models::TTSResponse.new(
+        audio_data: response.body,
+        duration: response["X-Audio-Duration"].to_f,
+        format: response["Content-Type"].to_s.include?("mp3") || response["Content-Type"].to_s.include?("mpeg") ? Models::AUDIO_MP3 : Models::AUDIO_WAV
+      )
+    end
+
+    def text_to_speech_stream(request)
+      response = request_json(:post, "/v1/text-to-speech/stream", request.to_h)
+      return enum_for(:text_to_speech_stream, request) unless block_given?
+
+      yield response.body
+    end
+
+    def text_to_speech_with_timestamps(request, granularity: nil)
+      unless granularity.nil? || %w[word char].include?(granularity)
+        raise ArgumentError, "granularity must be 'word' or 'char'"
+      end
+
+      path = "/v1/text-to-speech/with-timestamps"
+      query = granularity.nil? ? nil : { granularity: granularity }
+      response = request_json(:post, path, request.to_h, query)
+      Models::TTSWithTimestampsResponse.from_h(JSON.parse(response.body))
+    end
+
+    def get_my_subscription
+      Models::SubscriptionResponse.from_h(JSON.parse(request_json(:get, "/v1/users/me/subscription").body))
+    end
+
+    def get_voices_v2(filter = nil)
+      query = filter.respond_to?(:to_h) ? filter.to_h : filter
+      JSON.parse(request_json(:get, "/v2/voices", nil, query).body).map do |item|
+        Models::VoiceV2.from_h(item)
+      end
+    end
+
+    def get_voice_v2(voice_id)
+      voices = JSON.parse(request_json(:get, "/v2/voices/#{path_segment(voice_id)}").body).map do |item|
+        Models::VoiceV2.from_h(item)
+      end
+      raise NotFoundError, "Voice not found: #{voice_id}" if voices.empty?
+
+      voices.first
+    end
+
+    def clone_voice(audio:, filename:, name:, model:)
+      validate_clone_inputs(audio, name)
+      response = request_multipart("/v1/voices/clone", audio: audio, filename: filename, fields: { name: name, model: model })
+      Models::CustomVoice.from_h(JSON.parse(response.body))
+    end
+
+    def delete_voice(voice_id)
+      request_raw(:delete, "/v1/voices/#{path_segment(voice_id)}")
+      nil
+    end
+
+    private
+
+    def request_json(method, path, body = nil, query = nil)
+      headers = { "X-API-KEY" => api_key, "Content-Type" => "application/json" }
+      request_raw(method, path, body.nil? ? nil : JSON.generate(body), headers, query)
+    end
+
+    def request_raw(method, path, body = nil, headers = { "X-API-KEY" => api_key }, query = nil)
+      uri = build_uri(path, query)
+      request = request_for(method, uri)
+      headers.each { |key, value| request[key] = value }
+      request.body = body unless body.nil?
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+        http.write_timeout = @read_timeout if http.respond_to?(:write_timeout=)
+        http.request(request)
+      end
+      handle_error(response)
+      response
+    end
+
+    def request_multipart(path, audio:, filename:, fields:)
+      boundary = "typecast-ruby-#{SecureRandom.hex(8)}"
+      body = +""
+      fields.each do |name, value|
+        field_name = disposition_value(name)
+        field_value = multipart_body_value(value)
+        body << "--#{boundary}\r\n"
+        body << "Content-Disposition: form-data; name=\"#{field_name}\"\r\n\r\n"
+        body << "#{field_value}\r\n"
+      end
+      safe_filename = disposition_value(filename)
+      body << "--#{boundary}\r\n"
+      body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{safe_filename}\"\r\n"
+      body << "Content-Type: application/octet-stream\r\n\r\n"
+      body << audio
+      body << "\r\n--#{boundary}--\r\n"
+
+      request_raw(
+        :post,
+        path,
+        body,
+        {
+          "X-API-KEY" => api_key,
+          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+        }
+      )
+    end
+
+    def validate_clone_inputs(audio, name)
+      raise ArgumentError, "audio must be 25MB or smaller" if audio.bytesize > Models::CLONING_MAX_FILE_SIZE
+      raise ArgumentError, "name must be 1-#{Models::CLONING_NAME_MAX_LENGTH} chars" if name.empty? || name.length > Models::CLONING_NAME_MAX_LENGTH
+    end
+
+    def normalize_base_url(value)
+      raw = value.to_s
+      raw = "https://#{raw}" unless raw.match?(%r{\Ahttps?://}i)
+      uri = URI.parse(raw)
+      if uri.scheme != "https" && !local_uri?(uri)
+        raise ArgumentError, "base_url must use HTTPS"
+      end
+      uri.to_s
+    rescue URI::InvalidURIError
+      raise ArgumentError, "base_url must be a valid URL"
+    end
+
+    def local_uri?(uri)
+      uri.scheme == "http" && ["localhost", "127.0.0.1", "::1"].include?(uri.hostname)
+    end
+
+    def disposition_value(value)
+      string = value.to_s
+      raise ArgumentError, "multipart field values must not contain CR or LF" if string.match?(/[\r\n]/)
+
+      string.gsub(/["\\]/) { |character| "\\#{character}" }
+    end
+
+    def multipart_body_value(value)
+      string = value.to_s
+      raise ArgumentError, "multipart field values must not contain CR or LF" if string.match?(/[\r\n]/)
+
+      string
+    end
+
+    def path_segment(value)
+      URI.encode_www_form_component(value.to_s).gsub("+", "%20")
+    end
+
+    def build_uri(path, query)
+      uri = URI.join(base_url.end_with?("/") ? base_url : "#{base_url}/", path.sub(%r{\A/}, ""))
+      uri.query = URI.encode_www_form(query) if query && !query.empty?
+      uri
+    end
+
+    def request_for(method, uri)
+      case method
+      when :get then Net::HTTP::Get.new(uri)
+      when :post then Net::HTTP::Post.new(uri)
+      when :delete then Net::HTTP::Delete.new(uri)
+      else raise ArgumentError, "unsupported method: #{method}"
+      end
+    end
+
+    def handle_error(response)
+      return if response.code.to_i.between?(200, 299)
+
+      detail = extract_detail(response.body)
+      error = case response.code.to_i
+              when 400 then BadRequestError
+              when 401 then UnauthorizedError
+              when 402 then PaymentRequiredError
+              when 404 then NotFoundError
+              when 422 then UnprocessableEntityError
+              when 429 then RateLimitError
+              when 500 then InternalServerError
+              else ApiError
+              end
+      raise error.new(detail)
+    end
+
+    def extract_detail(body)
+      parsed = JSON.parse(body)
+      parsed["detail"] || parsed["error"] || parsed["message"] || body
+    rescue JSON::ParserError
+      body
+    end
+  end
+end

data/lib/typecast/errors.rb

@@ -0,0 +1,53 @@
+module Typecast
+  class ApiError < StandardError
+    attr_reader :status_code, :detail
+
+    def initialize(message, status_code, detail = nil)
+      super(detail.nil? || detail.empty? ? message : "#{message}: #{detail}")
+      @status_code = status_code
+      @detail = detail
+    end
+  end
+
+  class BadRequestError < ApiError
+    def initialize(detail = nil)
+      super("Bad request", 400, detail)
+    end
+  end
+
+  class UnauthorizedError < ApiError
+    def initialize(detail = nil)
+      super("Unauthorized", 401, detail)
+    end
+  end
+
+  class PaymentRequiredError < ApiError
+    def initialize(detail = nil)
+      super("Payment required", 402, detail)
+    end
+  end
+
+  class NotFoundError < ApiError
+    def initialize(detail = nil)
+      super("Not found", 404, detail)
+    end
+  end
+
+  class UnprocessableEntityError < ApiError
+    def initialize(detail = nil)
+      super("Unprocessable entity", 422, detail)
+    end
+  end
+
+  class RateLimitError < ApiError
+    def initialize(detail = nil)
+      super("Rate limit exceeded", 429, detail)
+    end
+  end
+
+  class InternalServerError < ApiError
+    def initialize(detail = nil)
+      super("Internal server error", 500, detail)
+    end
+  end
+end

data/lib/typecast/models.rb

@@ -0,0 +1,215 @@
+module Typecast
+  module Models
+    TTS_MODEL_V21 = "ssfm-v21"
+    TTS_MODEL_V30 = "ssfm-v30"
+    AUDIO_WAV = "wav"
+    AUDIO_MP3 = "mp3"
+    CLONING_MAX_FILE_SIZE = 25 * 1024 * 1024
+    CLONING_NAME_MAX_LENGTH = 30
+
+    LANGUAGE_CODES = %w[
+      eng kor jpn spa deu fra ita pol nld rus ell tam tgl fin zho slk ara hrv
+      ukr ind dan swe msa ces por bul ron ben hin hun nan nor pan tha tur vie yue
+    ].freeze
+
+    class Output
+      attr_reader :volume, :target_lufs, :audio_pitch, :audio_tempo, :audio_format
+
+      def initialize(volume: nil, target_lufs: nil, audio_pitch: nil, audio_tempo: nil, audio_format: nil)
+        @volume = volume
+        @target_lufs = target_lufs
+        @audio_pitch = audio_pitch
+        @audio_tempo = audio_tempo
+        @audio_format = audio_format
+      end
+
+      def to_h
+        Models.compact(
+          volume: volume,
+          target_lufs: target_lufs,
+          audio_pitch: audio_pitch,
+          audio_tempo: audio_tempo,
+          audio_format: audio_format
+        )
+      end
+    end
+
+    class OutputStream
+      attr_reader :audio_pitch, :audio_tempo, :audio_format
+
+      def initialize(audio_pitch: nil, audio_tempo: nil, audio_format: nil)
+        @audio_pitch = audio_pitch
+        @audio_tempo = audio_tempo
+        @audio_format = audio_format
+      end
+
+      def to_h
+        Models.compact(audio_pitch: audio_pitch, audio_tempo: audio_tempo, audio_format: audio_format)
+      end
+    end
+
+    class Prompt
+      attr_reader :emotion_preset, :emotion_intensity
+
+      def initialize(emotion_preset: nil, emotion_intensity: nil)
+        @emotion_preset = emotion_preset
+        @emotion_intensity = emotion_intensity
+      end
+
+      def to_h
+        Models.compact(emotion_preset: emotion_preset, emotion_intensity: emotion_intensity)
+      end
+    end
+
+    class PresetPrompt
+      attr_reader :emotion_preset, :emotion_intensity
+
+      def initialize(emotion_preset: nil, emotion_intensity: nil)
+        @emotion_preset = emotion_preset
+        @emotion_intensity = emotion_intensity
+      end
+
+      def to_h
+        Models.compact(emotion_type: "preset", emotion_preset: emotion_preset, emotion_intensity: emotion_intensity)
+      end
+    end
+
+    class SmartPrompt
+      attr_reader :previous_text, :next_text
+
+      def initialize(previous_text: nil, next_text: nil)
+        @previous_text = previous_text
+        @next_text = next_text
+      end
+
+      def to_h
+        Models.compact(emotion_type: "smart", previous_text: previous_text, next_text: next_text)
+      end
+    end
+
+    class TTSRequest
+      attr_reader :voice_id, :text, :model, :language, :prompt, :output, :seed
+
+      def initialize(voice_id:, text:, model:, language: nil, prompt: nil, output: nil, seed: nil)
+        @voice_id = voice_id
+        @text = text
+        @model = model
+        @language = language
+        @prompt = prompt
+        @output = output
+        @seed = seed
+      end
+
+      def to_h
+        Models.compact(
+          voice_id: voice_id,
+          text: text,
+          model: model,
+          language: language,
+          prompt: Models.value_to_h(prompt),
+          output: Models.value_to_h(output),
+          seed: seed
+        )
+      end
+    end
+
+    class TTSRequestStream < TTSRequest
+    end
+
+    class TTSResponse
+      attr_reader :audio_data, :duration, :format
+
+      def initialize(audio_data:, duration:, format:)
+        @audio_data = audio_data
+        @duration = duration
+        @format = format
+      end
+    end
+
+    class SubscriptionResponse
+      attr_reader :plan, :plan_credits, :used_credits, :concurrency_limit
+
+      def self.from_h(hash)
+        credits = hash.fetch("credits", {})
+        limits = hash.fetch("limits", {})
+        new(
+          plan: hash.fetch("plan", ""),
+          plan_credits: credits.fetch("plan_credits", 0),
+          used_credits: credits.fetch("used_credits", 0),
+          concurrency_limit: limits.fetch("concurrency_limit", 0)
+        )
+      end
+
+      def initialize(plan:, plan_credits:, used_credits:, concurrency_limit:)
+        @plan = plan
+        @plan_credits = plan_credits
+        @used_credits = used_credits
+        @concurrency_limit = concurrency_limit
+      end
+    end
+
+    class VoiceV2
+      attr_reader :voice_id, :voice_name, :models, :gender, :age, :use_cases
+
+      def self.from_h(hash)
+        new(
+          voice_id: hash.fetch("voice_id", ""),
+          voice_name: hash.fetch("voice_name", ""),
+          models: hash.fetch("models", []),
+          gender: hash["gender"],
+          age: hash["age"],
+          use_cases: hash.fetch("use_cases", [])
+        )
+      end
+
+      def initialize(voice_id:, voice_name:, models:, gender: nil, age: nil, use_cases: [])
+        @voice_id = voice_id
+        @voice_name = voice_name
+        @models = models
+        @gender = gender
+        @age = age
+        @use_cases = use_cases
+      end
+    end
+
+    class VoicesV2Filter
+      attr_reader :model, :gender, :age, :use_cases
+
+      def initialize(model: nil, gender: nil, age: nil, use_cases: nil)
+        @model = model
+        @gender = gender
+        @age = age
+        @use_cases = use_cases
+      end
+
+      def to_h
+        Models.compact(model: model, gender: gender, age: age, use_cases: use_cases&.join(","))
+      end
+    end
+
+    class CustomVoice
+      attr_reader :voice_id, :name, :model
+
+      def self.from_h(hash)
+        new(voice_id: hash.fetch("voice_id", ""), name: hash.fetch("name", ""), model: hash["model"])
+      end
+
+      def initialize(voice_id:, name:, model: nil)
+        @voice_id = voice_id
+        @name = name
+        @model = model
+      end
+    end
+
+    def self.compact(hash)
+      hash.reject { |_key, value| value.nil? }
+    end
+
+    def self.value_to_h(value)
+      return nil if value.nil?
+      return value.to_h if value.respond_to?(:to_h)
+      value
+    end
+
+  end
+end

data/lib/typecast/timestamps.rb

@@ -0,0 +1,96 @@
+require "base64"
+
+module Typecast
+  module Models
+    class AlignmentSegmentWord
+      attr_reader :word, :start_time, :end_time
+
+      def self.from_h(hash)
+        new(word: hash.fetch("word", ""), start_time: hash.fetch("start_time", 0).to_f, end_time: hash.fetch("end_time", 0).to_f)
+      end
+
+      def initialize(word:, start_time:, end_time:)
+        @word = word
+        @start_time = start_time
+        @end_time = end_time
+      end
+    end
+
+    class AlignmentSegmentCharacter
+      attr_reader :character, :start_time, :end_time
+
+      def self.from_h(hash)
+        new(character: hash.fetch("character", ""), start_time: hash.fetch("start_time", 0).to_f, end_time: hash.fetch("end_time", 0).to_f)
+      end
+
+      def initialize(character:, start_time:, end_time:)
+        @character = character
+        @start_time = start_time
+        @end_time = end_time
+      end
+    end
+
+    class TTSWithTimestampsResponse
+      attr_reader :audio, :audio_format, :audio_duration, :words, :characters
+
+      def self.from_h(hash)
+        new(
+          audio: hash.fetch("audio", ""),
+          audio_format: hash.fetch("audio_format", AUDIO_WAV),
+          audio_duration: hash.fetch("audio_duration", 0).to_f,
+          words: hash.fetch("words", []).map { |item| AlignmentSegmentWord.from_h(item) },
+          characters: hash.fetch("characters", []).map { |item| AlignmentSegmentCharacter.from_h(item) }
+        )
+      end
+
+      def initialize(audio:, audio_format:, audio_duration:, words: [], characters: [])
+        @audio = audio
+        @audio_format = audio_format
+        @audio_duration = audio_duration
+        @words = words
+        @characters = characters
+      end
+
+      def audio_bytes
+        Base64.decode64(audio)
+      end
+
+      def save_audio(path)
+        File.binwrite(path, audio_bytes)
+      end
+
+      def to_srt
+        caption_lines(webvtt: false)
+      end
+
+      def to_vtt
+        "WEBVTT\n\n#{caption_lines(webvtt: true)}"
+      end
+
+      private
+
+      def caption_lines(webvtt:)
+        segments = words.empty? ? characters.map { |c| [c.character, c.start_time, c.end_time] } : words.map { |w| [w.word, w.start_time, w.end_time] }
+        raise ArgumentError, "No alignment segments are available" if segments.empty?
+
+        lines = []
+        segments.each_with_index do |segment, index|
+          lines << (index + 1).to_s unless webvtt
+          lines << "#{format_time(segment[1], webvtt)} --> #{format_time(segment[2], webvtt)}"
+          lines << segment[0]
+          lines << ""
+        end
+        lines.join("\n")
+      end
+
+      def format_time(seconds, webvtt)
+        millis = (seconds * 1000).round
+        hours = millis / 3_600_000
+        minutes = (millis % 3_600_000) / 60_000
+        secs = (millis % 60_000) / 1000
+        ms = millis % 1000
+        format("%02d:%02d:%02d%s%03d", hours, minutes, secs, webvtt ? "." : ",", ms)
+      end
+    end
+  end
+end

data/lib/typecast/version.rb

@@ -0,0 +1,3 @@
+module Typecast
+  VERSION = "0.1.0"
+end

data/lib/typecast.rb

@@ -0,0 +1,5 @@
+require "typecast/client"
+require "typecast/errors"
+require "typecast/models"
+require "typecast/timestamps"
+require "typecast/version"

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: typecast-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Neosapience
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A Ruby client for Typecast TTS, timestamps, voices, subscription, and
+  quick cloning APIs.
+email:
+- support@neosapience.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- THIRD-PARTY-LICENSES.md
+- lib/typecast.rb
+- lib/typecast/client.rb
+- lib/typecast/errors.rb
+- lib/typecast/models.rb
+- lib/typecast/timestamps.rb
+- lib/typecast/version.rb
+homepage: https://github.com/neosapience/typecast-sdk/tree/main/typecast-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Official Ruby SDK for the Typecast Text-to-Speech API
+test_files: []