zernio-sdk 0.0.780 → 0.0.782

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 530bf22aee2cf3406e1dde1b5eaef370273d90b1798a838cf33e2584e38934d5
-  data.tar.gz: e273922c245bc58aebdd6a13712951a975cdbf81624decc93412f76a885403b3
+  metadata.gz: f6cf84a34aa57877a9f48a6addfa1625b2f9e5d3438d8bc88063134ae060f818
+  data.tar.gz: 6fcdb8f1265c28c062e6c43ca994486514622ab15e1b6f71b2059ea8aab019d8
 SHA512:
-  metadata.gz: 8c0701923731d666b44fcd04f23968377cbb764cce87c95b4a3934bd81581585ce004417522b71c7734f3bf76e0a09b2bcd5a045564be9239b4d9cc1674a54fa
-  data.tar.gz: 490dfb0369272829134315f7bb8c6b8144346257e7c65db25e45f8331428a57c66e97eb4e5f0684039559f730b214e36ec4d6f78f28a2be1febea606869658a1
+  metadata.gz: 33a39723db63a41bf840c6bfab608f628bed84979b9c703565d595dc1ae7ab8b092696de700c33732949ff30d150696caf617635661487271b45ddfa96c89f3f
+  data.tar.gz: bf8c0f80e48a9d9028a6aa09690f4b9e22d9da3ed2d288f4574d58e7b68f3191009a2dc232b3b8a72a2416051495b7d9e70aca7266e849fb9d2771f577b67f1b

data/README.md

@@ -277,6 +277,7 @@ Class | Method | HTTP request | Description
 *Zernio::ConnectApi* | [**get_shopify_connect_url**](docs/ConnectApi.md#get_shopify_connect_url) | **GET** /v1/connect/shopify | Get Shopify OAuth connect URL
 *Zernio::ConnectApi* | [**get_subreddit_rules**](docs/ConnectApi.md#get_subreddit_rules) | **GET** /v1/accounts/{accountId}/reddit-subreddits/{subreddit}/rules | Get subreddit rules
 *Zernio::ConnectApi* | [**get_telegram_connect_status**](docs/ConnectApi.md#get_telegram_connect_status) | **GET** /v1/connect/telegram | Generate Telegram code
+*Zernio::ConnectApi* | [**get_youtube_captions**](docs/ConnectApi.md#get_youtube_captions) | **GET** /v1/accounts/{accountId}/youtube-captions | Get a YouTube video transcript
 *Zernio::ConnectApi* | [**get_youtube_playlists**](docs/ConnectApi.md#get_youtube_playlists) | **GET** /v1/accounts/{accountId}/youtube-playlists | List YouTube playlists
 *Zernio::ConnectApi* | [**handle_o_auth_callback**](docs/ConnectApi.md#handle_o_auth_callback) | **POST** /v1/connect/{platform} | Complete OAuth callback
 *Zernio::ConnectApi* | [**initiate_telegram_connect**](docs/ConnectApi.md#initiate_telegram_connect) | **POST** /v1/connect/telegram | Connect Telegram directly
@@ -1454,6 +1455,9 @@ Class | Method | HTTP request | Description
  - [Zernio::GetYouTubeDemographics412Response](docs/GetYouTubeDemographics412Response.md)
  - [Zernio::GetYouTubeDemographics412ResponseScopeStatus](docs/GetYouTubeDemographics412ResponseScopeStatus.md)
  - [Zernio::GetYouTubeVideoRetention404Response](docs/GetYouTubeVideoRetention404Response.md)
+ - [Zernio::GetYoutubeCaptions200Response](docs/GetYoutubeCaptions200Response.md)
+ - [Zernio::GetYoutubeCaptions200ResponseAvailableTracksInner](docs/GetYoutubeCaptions200ResponseAvailableTracksInner.md)
+ - [Zernio::GetYoutubeCaptions200ResponseCuesInner](docs/GetYoutubeCaptions200ResponseCuesInner.md)
  - [Zernio::GetYoutubePlaylists200Response](docs/GetYoutubePlaylists200Response.md)
  - [Zernio::GetYoutubePlaylists200ResponsePlaylistsInner](docs/GetYoutubePlaylists200ResponsePlaylistsInner.md)
  - [Zernio::GoogleBusinessPlatformData](docs/GoogleBusinessPlatformData.md)

data/docs/ConnectApi.md

@@ -28,6 +28,7 @@ All URIs are relative to *https://zernio.com/api*
 | [**get_shopify_connect_url**](ConnectApi.md#get_shopify_connect_url) | **GET** /v1/connect/shopify | Get Shopify OAuth connect URL |
 | [**get_subreddit_rules**](ConnectApi.md#get_subreddit_rules) | **GET** /v1/accounts/{accountId}/reddit-subreddits/{subreddit}/rules | Get subreddit rules |
 | [**get_telegram_connect_status**](ConnectApi.md#get_telegram_connect_status) | **GET** /v1/connect/telegram | Generate Telegram code |
+| [**get_youtube_captions**](ConnectApi.md#get_youtube_captions) | **GET** /v1/accounts/{accountId}/youtube-captions | Get a YouTube video transcript |
 | [**get_youtube_playlists**](ConnectApi.md#get_youtube_playlists) | **GET** /v1/accounts/{accountId}/youtube-playlists | List YouTube playlists |
 | [**handle_o_auth_callback**](ConnectApi.md#handle_o_auth_callback) | **POST** /v1/connect/{platform} | Complete OAuth callback |
 | [**initiate_telegram_connect**](ConnectApi.md#initiate_telegram_connect) | **POST** /v1/connect/telegram | Connect Telegram directly |
@@ -1765,6 +1766,85 @@ end
 - **Accept**: application/json
 
 
+## get_youtube_captions
+
+> <GetYoutubeCaptions200Response> get_youtube_captions(account_id, video_id, opts)
+
+Get a YouTube video transcript
+
+Returns the caption track YouTube already holds for one of the connected channel's own videos, as plain text plus timed cues. Use it instead of downloading and transcribing the video yourself.  Auto-generated (ASR) tracks are included: YouTube serves them to the channel owner, which is what the connected account is. Uploaded tracks win over auto-generated ones when both exist for a language.  Caching: we store the transcript on first read and serve it from there afterwards, so you do not need to cache it yourself. A cached read costs no YouTube quota and does not call YouTube at all. `source` tells you which happened (`youtube` on the first read, `cache` after). Pass `refresh=true` only when the captions actually changed on YouTube, since that re-downloads.  Notes: - Only videos owned by this connected channel. Anything else returns 404. - `contentDetails.caption` in YouTube's own API reads `false` on videos that DO have a serving auto-generated track, so it is not a usable availability signal. Call this endpoint and handle the 404. - YouTube generates auto-captions only for videos with recognisable speech, and can take a few hours after upload to publish them. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'zernio-sdk'
+# setup authorization
+Zernio.configure do |config|
+  # Configure Bearer authorization (JWT): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Zernio::ConnectApi.new
+account_id = 'account_id_example' # String | The connected YouTube account.
+video_id = 'video_id_example' # String | The YouTube video id (the `platformPostId` on a synced external post).
+opts = {
+  language: 'language_example', # String | BCP-47 language tag as YouTube labels the track. `en` also matches an `en-GB` track. Omit to take the best available track.
+  format: 'json', # String | `json` returns timed `cues`; `srt` returns the raw SubRip body instead. `text` is present either way.
+  refresh: true # Boolean | Re-download from YouTube instead of serving the stored copy. Spends 200 quota units.
+}
+
+begin
+  # Get a YouTube video transcript
+  result = api_instance.get_youtube_captions(account_id, video_id, opts)
+  p result
+rescue Zernio::ApiError => e
+  puts "Error when calling ConnectApi->get_youtube_captions: #{e}"
+end
+```
+
+#### Using the get_youtube_captions_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetYoutubeCaptions200Response>, Integer, Hash)> get_youtube_captions_with_http_info(account_id, video_id, opts)
+
+```ruby
+begin
+  # Get a YouTube video transcript
+  data, status_code, headers = api_instance.get_youtube_captions_with_http_info(account_id, video_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetYoutubeCaptions200Response>
+rescue Zernio::ApiError => e
+  puts "Error when calling ConnectApi->get_youtube_captions_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **account_id** | **String** | The connected YouTube account. |  |
+| **video_id** | **String** | The YouTube video id (the &#x60;platformPostId&#x60; on a synced external post). |  |
+| **language** | **String** | BCP-47 language tag as YouTube labels the track. &#x60;en&#x60; also matches an &#x60;en-GB&#x60; track. Omit to take the best available track. | [optional] |
+| **format** | **String** | &#x60;json&#x60; returns timed &#x60;cues&#x60;; &#x60;srt&#x60; returns the raw SubRip body instead. &#x60;text&#x60; is present either way. | [optional][default to &#39;json&#39;] |
+| **refresh** | **Boolean** | Re-download from YouTube instead of serving the stored copy. Spends 200 quota units. | [optional][default to false] |
+
+### Return type
+
+[**GetYoutubeCaptions200Response**](GetYoutubeCaptions200Response.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
 ## get_youtube_playlists
 
 > <GetYoutubePlaylists200Response> get_youtube_playlists(account_id)

data/docs/GetYoutubeCaptions200Response.md

@@ -0,0 +1,38 @@
+# Zernio::GetYoutubeCaptions200Response
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **account_id** | **String** |  | [optional] |
+| **video_id** | **String** |  | [optional] |
+| **language** | **String** | The language of the returned track. | [optional] |
+| **track_id** | **String** | YouTube's own caption track id. | [optional] |
+| **track_kind** | **String** | `asr` is YouTube's auto-generated track; `standard` was uploaded by the channel. | [optional] |
+| **source** | **String** | `cache` when served from our stored copy, `youtube` when this call spent the quota units. | [optional] |
+| **fetched_at** | **Time** | When the stored copy was downloaded from YouTube. | [optional] |
+| **text** | **String** | The whole transcript as one paragraph, no timings. | [optional] |
+| **cues** | [**Array<GetYoutubeCaptions200ResponseCuesInner>**](GetYoutubeCaptions200ResponseCuesInner.md) | Timed cues. Present when format is json. Auto-generated cues overlap in time by design (captions roll), so `start` can precede the previous cue's `end`. | [optional] |
+| **srt** | **String** | Raw SubRip body. Present when format is srt. | [optional] |
+| **available_tracks** | [**Array<GetYoutubeCaptions200ResponseAvailableTracksInner>**](GetYoutubeCaptions200ResponseAvailableTracksInner.md) | Every track on the video, so you can re-request another language. On a cached read this is the listing as it stood when we downloaded, so a language added to the video since then appears only after a `refresh=true` or when you request that language directly. | [optional] |
+
+## Example
+
+```ruby
+require 'zernio-sdk'
+
+instance = Zernio::GetYoutubeCaptions200Response.new(
+  account_id: null,
+  video_id: null,
+  language: null,
+  track_id: null,
+  track_kind: null,
+  source: null,
+  fetched_at: null,
+  text: null,
+  cues: null,
+  srt: null,
+  available_tracks: null
+)
+```
+

data/docs/GetYoutubeCaptions200ResponseAvailableTracksInner.md

@@ -0,0 +1,24 @@
+# Zernio::GetYoutubeCaptions200ResponseAvailableTracksInner
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **track_id** | **String** |  | [optional] |
+| **language** | **String** |  | [optional] |
+| **track_kind** | **String** |  | [optional] |
+| **name** | **String** | The track's display name. Empty for auto-generated tracks. | [optional] |
+
+## Example
+
+```ruby
+require 'zernio-sdk'
+
+instance = Zernio::GetYoutubeCaptions200ResponseAvailableTracksInner.new(
+  track_id: null,
+  language: null,
+  track_kind: null,
+  name: null
+)
+```
+

data/docs/GetYoutubeCaptions200ResponseCuesInner.md

@@ -0,0 +1,22 @@
+# Zernio::GetYoutubeCaptions200ResponseCuesInner
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **start** | **Float** | Seconds from the start of the video. | [optional] |
+| **_end** | **Float** |  | [optional] |
+| **text** | **String** |  | [optional] |
+
+## Example
+
+```ruby
+require 'zernio-sdk'
+
+instance = Zernio::GetYoutubeCaptions200ResponseCuesInner.new(
+  start: null,
+  _end: null,
+  text: null
+)
+```
+

data/lib/zernio-sdk/api/connect_api.rb

@@ -1714,6 +1714,89 @@ module Zernio
       return data, status_code, headers
     end
 
+    # Get a YouTube video transcript
+    # Returns the caption track YouTube already holds for one of the connected channel's own videos, as plain text plus timed cues. Use it instead of downloading and transcribing the video yourself.  Auto-generated (ASR) tracks are included: YouTube serves them to the channel owner, which is what the connected account is. Uploaded tracks win over auto-generated ones when both exist for a language.  Caching: we store the transcript on first read and serve it from there afterwards, so you do not need to cache it yourself. A cached read costs no YouTube quota and does not call YouTube at all. `source` tells you which happened (`youtube` on the first read, `cache` after). Pass `refresh=true` only when the captions actually changed on YouTube, since that re-downloads.  Notes: - Only videos owned by this connected channel. Anything else returns 404. - `contentDetails.caption` in YouTube's own API reads `false` on videos that DO have a serving auto-generated track, so it is not a usable availability signal. Call this endpoint and handle the 404. - YouTube generates auto-captions only for videos with recognisable speech, and can take a few hours after upload to publish them. 
+    # @param account_id [String] The connected YouTube account.
+    # @param video_id [String] The YouTube video id (the `platformPostId` on a synced external post).
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :language BCP-47 language tag as YouTube labels the track. `en` also matches an `en-GB` track. Omit to take the best available track.
+    # @option opts [String] :format `json` returns timed `cues`; `srt` returns the raw SubRip body instead. `text` is present either way. (default to 'json')
+    # @option opts [Boolean] :refresh Re-download from YouTube instead of serving the stored copy. Spends 200 quota units. (default to false)
+    # @return [GetYoutubeCaptions200Response]
+    def get_youtube_captions(account_id, video_id, opts = {})
+      data, _status_code, _headers = get_youtube_captions_with_http_info(account_id, video_id, opts)
+      data
+    end
+
+    # Get a YouTube video transcript
+    # Returns the caption track YouTube already holds for one of the connected channel's own videos, as plain text plus timed cues. Use it instead of downloading and transcribing the video yourself.  Auto-generated (ASR) tracks are included: YouTube serves them to the channel owner, which is what the connected account is. Uploaded tracks win over auto-generated ones when both exist for a language.  Caching: we store the transcript on first read and serve it from there afterwards, so you do not need to cache it yourself. A cached read costs no YouTube quota and does not call YouTube at all. `source` tells you which happened (`youtube` on the first read, `cache` after). Pass `refresh=true` only when the captions actually changed on YouTube, since that re-downloads.  Notes: - Only videos owned by this connected channel. Anything else returns 404. - `contentDetails.caption` in YouTube's own API reads `false` on videos that DO have a serving auto-generated track, so it is not a usable availability signal. Call this endpoint and handle the 404. - YouTube generates auto-captions only for videos with recognisable speech, and can take a few hours after upload to publish them. 
+    # @param account_id [String] The connected YouTube account.
+    # @param video_id [String] The YouTube video id (the `platformPostId` on a synced external post).
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :language BCP-47 language tag as YouTube labels the track. `en` also matches an `en-GB` track. Omit to take the best available track.
+    # @option opts [String] :format `json` returns timed `cues`; `srt` returns the raw SubRip body instead. `text` is present either way. (default to 'json')
+    # @option opts [Boolean] :refresh Re-download from YouTube instead of serving the stored copy. Spends 200 quota units. (default to false)
+    # @return [Array<(GetYoutubeCaptions200Response, Integer, Hash)>] GetYoutubeCaptions200Response data, response status code and response headers
+    def get_youtube_captions_with_http_info(account_id, video_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: ConnectApi.get_youtube_captions ...'
+      end
+      # verify the required parameter 'account_id' is set
+      if @api_client.config.client_side_validation && account_id.nil?
+        fail ArgumentError, "Missing the required parameter 'account_id' when calling ConnectApi.get_youtube_captions"
+      end
+      # verify the required parameter 'video_id' is set
+      if @api_client.config.client_side_validation && video_id.nil?
+        fail ArgumentError, "Missing the required parameter 'video_id' when calling ConnectApi.get_youtube_captions"
+      end
+      allowable_values = ["json", "srt"]
+      if @api_client.config.client_side_validation && opts[:'format'] && !allowable_values.include?(opts[:'format'])
+        fail ArgumentError, "invalid value for \"format\", must be one of #{allowable_values}"
+      end
+      # resource path
+      local_var_path = '/v1/accounts/{accountId}/youtube-captions'.sub('{' + 'accountId' + '}', CGI.escape(account_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'videoId'] = video_id
+      query_params[:'language'] = opts[:'language'] if !opts[:'language'].nil?
+      query_params[:'format'] = opts[:'format'] if !opts[:'format'].nil?
+      query_params[:'refresh'] = opts[:'refresh'] if !opts[:'refresh'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'GetYoutubeCaptions200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['bearerAuth']
+
+      new_options = opts.merge(
+        :operation => :"ConnectApi.get_youtube_captions",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: ConnectApi#get_youtube_captions\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # List YouTube playlists
     # Returns the playlists available for a connected YouTube account. Use this to get a playlist ID when creating a YouTube post with the playlistId field.
     # @param account_id [String] 

data/lib/zernio-sdk/models/get_youtube_captions200_response.rb

@@ -0,0 +1,296 @@
+=begin
+#Zernio API
+
+#API reference for Zernio. Authenticate with a Bearer API key. Base URL: https://zernio.com/api  Versioning and deprecation: all endpoints are versioned in the URL path (current version: /v1). Breaking changes only ship in a new path version; existing versions keep working. Deprecated operations are marked 'deprecated: true' in this spec and announced in the changelog (https://zernio.com/changelog) before removal.  Errors: every 4xx/5xx response is application/json with a machine-readable 'code' and a human-readable 'error' message (see the ErrorResponse schema). 
+
+The version of the OpenAPI document: 1.0.4
+Contact: support@zernio.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.19.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Zernio
+  class GetYoutubeCaptions200Response < ApiModelBase
+    attr_accessor :account_id
+
+    attr_accessor :video_id
+
+    # The language of the returned track.
+    attr_accessor :language
+
+    # YouTube's own caption track id.
+    attr_accessor :track_id
+
+    # `asr` is YouTube's auto-generated track; `standard` was uploaded by the channel.
+    attr_accessor :track_kind
+
+    # `cache` when served from our stored copy, `youtube` when this call spent the quota units.
+    attr_accessor :source
+
+    # When the stored copy was downloaded from YouTube.
+    attr_accessor :fetched_at
+
+    # The whole transcript as one paragraph, no timings.
+    attr_accessor :text
+
+    # Timed cues. Present when format is json. Auto-generated cues overlap in time by design (captions roll), so `start` can precede the previous cue's `end`.
+    attr_accessor :cues
+
+    # Raw SubRip body. Present when format is srt.
+    attr_accessor :srt
+
+    # Every track on the video, so you can re-request another language. On a cached read this is the listing as it stood when we downloaded, so a language added to the video since then appears only after a `refresh=true` or when you request that language directly.
+    attr_accessor :available_tracks
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'account_id' => :'accountId',
+        :'video_id' => :'videoId',
+        :'language' => :'language',
+        :'track_id' => :'trackId',
+        :'track_kind' => :'trackKind',
+        :'source' => :'source',
+        :'fetched_at' => :'fetchedAt',
+        :'text' => :'text',
+        :'cues' => :'cues',
+        :'srt' => :'srt',
+        :'available_tracks' => :'availableTracks'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'account_id' => :'String',
+        :'video_id' => :'String',
+        :'language' => :'String',
+        :'track_id' => :'String',
+        :'track_kind' => :'String',
+        :'source' => :'String',
+        :'fetched_at' => :'Time',
+        :'text' => :'String',
+        :'cues' => :'Array<GetYoutubeCaptions200ResponseCuesInner>',
+        :'srt' => :'String',
+        :'available_tracks' => :'Array<GetYoutubeCaptions200ResponseAvailableTracksInner>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Zernio::GetYoutubeCaptions200Response` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Zernio::GetYoutubeCaptions200Response`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'account_id')
+        self.account_id = attributes[:'account_id']
+      end
+
+      if attributes.key?(:'video_id')
+        self.video_id = attributes[:'video_id']
+      end
+
+      if attributes.key?(:'language')
+        self.language = attributes[:'language']
+      end
+
+      if attributes.key?(:'track_id')
+        self.track_id = attributes[:'track_id']
+      end
+
+      if attributes.key?(:'track_kind')
+        self.track_kind = attributes[:'track_kind']
+      end
+
+      if attributes.key?(:'source')
+        self.source = attributes[:'source']
+      end
+
+      if attributes.key?(:'fetched_at')
+        self.fetched_at = attributes[:'fetched_at']
+      end
+
+      if attributes.key?(:'text')
+        self.text = attributes[:'text']
+      end
+
+      if attributes.key?(:'cues')
+        if (value = attributes[:'cues']).is_a?(Array)
+          self.cues = value
+        end
+      end
+
+      if attributes.key?(:'srt')
+        self.srt = attributes[:'srt']
+      end
+
+      if attributes.key?(:'available_tracks')
+        if (value = attributes[:'available_tracks']).is_a?(Array)
+          self.available_tracks = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      track_kind_validator = EnumAttributeValidator.new('String', ["asr", "standard"])
+      return false unless track_kind_validator.valid?(@track_kind)
+      source_validator = EnumAttributeValidator.new('String', ["cache", "youtube"])
+      return false unless source_validator.valid?(@source)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] track_kind Object to be assigned
+    def track_kind=(track_kind)
+      validator = EnumAttributeValidator.new('String', ["asr", "standard"])
+      unless validator.valid?(track_kind)
+        fail ArgumentError, "invalid value for \"track_kind\", must be one of #{validator.allowable_values}."
+      end
+      @track_kind = track_kind
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] source Object to be assigned
+    def source=(source)
+      validator = EnumAttributeValidator.new('String', ["cache", "youtube"])
+      unless validator.valid?(source)
+        fail ArgumentError, "invalid value for \"source\", must be one of #{validator.allowable_values}."
+      end
+      @source = source
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          account_id == o.account_id &&
+          video_id == o.video_id &&
+          language == o.language &&
+          track_id == o.track_id &&
+          track_kind == o.track_kind &&
+          source == o.source &&
+          fetched_at == o.fetched_at &&
+          text == o.text &&
+          cues == o.cues &&
+          srt == o.srt &&
+          available_tracks == o.available_tracks
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [account_id, video_id, language, track_id, track_kind, source, fetched_at, text, cues, srt, available_tracks].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end