anki_connect 0.1.1 → 0.2.0

data/lib/anki_connect/notes.rb

@@ -7,38 +7,59 @@ module AnkiConnect
       # Creates a new note.
       #
       # @param deck_name [String] Target deck
-      # @param model_name [String] Note type
+      # @param note_type_name [String] Note type
       # @param fields [Hash] Field names to values
       # @param tags [Array<String>] Tags (optional)
       # @param media [Hash, nil] Media to add (audio:, video:, picture: arrays)
-      # @param options [Hash, nil] Options (allowDuplicate, duplicateScope, etc.)
-      # @return [Integer, nil] Note ID on success, nil on failure
-      def add_note(deck_name:, model_name:, fields:, tags: [], media: nil, options: nil)
-        note = { deckName: deck_name, modelName: model_name, fields: fields, tags: tags }
-        note.merge!(media) if media
-        note[:options] = options if options
-        request(:addNote, note: note)
+      # @param options [Hash, nil] Options such as allow_duplicate and duplicate_scope
+      # @return [Integer] Note ID on success
+      def add_note(deck_name:, note_type_name:, fields:, tags: [], media: nil, options: nil)
+        note = { deck_name: deck_name, note_type_name: note_type_name, fields: fields, tags: tags }
+        note[:media] = media unless media.nil?
+        note[:options] = options unless options.nil?
+        request(:addNote, note: normalize_note(note))
       end
 
       # Creates multiple notes.
       #
       # @param notes [Array<Hash>] Array of note hashes (same keys as add_note)
-      # @return [Array<Integer, nil>] Array of note IDs (nil for failed notes)
+      # The operation is all-or-nothing; AnkiConnect rolls back all additions if any note fails.
+      #
+      # @return [Array<Integer>] Array of note IDs
       def add_notes(notes)
-        request(:addNotes, notes: notes)
+        request(:addNotes, notes: notes.map { |note| normalize_note(note) })
       end
 
-      # Checks if notes can be added.
+      # Checks if one note can be added.
       #
-      # @param notes [Array<Hash>] Array of candidate note objects
-      # @param details [Boolean] If true, returns error details (default: false)
-      # @return [Array<Boolean>, Array<Hash>] Array of booleans, or hashes with canAdd and error if details=true
-      def can_add_notes(notes, details: false)
-        if details
-          request(:canAddNotesWithErrorDetail, notes: notes)
-        else
-          request(:canAddNotes, notes: notes)
-        end
+      # @param note [Hash] Candidate note using snake_case keys
+      # @return [Boolean] Whether the note can be added
+      def note_addable?(note)
+        request(:canAddNote, note: normalize_note(note))
+      end
+
+      # Gets addability details for one note.
+      #
+      # @param note [Hash] Candidate note
+      # @return [Hash] Hash with canAdd and optional error
+      def note_addability(note)
+        request(:canAddNoteWithErrorDetail, note: normalize_note(note))
+      end
+
+      # Gets addability status for each note, preserving input order.
+      #
+      # @param notes [Array<Hash>] Candidate notes
+      # @return [Array<Boolean>] Addability statuses
+      def note_addability_statuses(notes)
+        request(:canAddNotes, notes: notes.map { |note| normalize_note(note) })
+      end
+
+      # Gets addability details for each note, preserving input order.
+      #
+      # @param notes [Array<Hash>] Candidate notes
+      # @return [Array<Hash>] Hashes with canAdd and optional error
+      def note_addability_details(notes)
+        request(:canAddNotesWithErrorDetail, notes: notes.map { |note| normalize_note(note) })
       end
 
       # Updates a note's fields, tags, or media.
@@ -49,29 +70,56 @@ module AnkiConnect
       # @param media [Hash, nil] Media to add (audio:, video:, picture: arrays)
       # @return [nil]
       def update_note(id, fields: nil, tags: nil, media: nil)
+        if fields.nil? && tags.nil? && media.nil?
+          raise ArgumentError, 'provide fields, tags, or media to update'
+        end
+
         note = { id: id }
-        note[:fields] = fields if fields
-        note[:tags] = tags if tags
-        note.merge!(media) if media
+        note[:fields] = fields || {} unless fields.nil? && media.nil?
+        note[:tags] = tags unless tags.nil?
+        merge_media!(note, media) unless media.nil?
         request(:updateNote, note: note)
       end
 
-      # Changes a note's model type.
+      # Updates a note's fields and optional media.
       #
       # @param id [Integer] Note ID
-      # @param model_name [String] New model name
-      # @param fields [Hash] New field values
-      # @param tags [Array<String>] New tags
+      # @param fields [Hash] Field names to new values
+      # @param media [Hash, nil] Media to add (audio:, video:, picture:)
       # @return [nil]
-      def change_note_model(id, model_name:, fields:, tags:)
-        request(:updateNoteModel, note: { id: id, modelName: model_name, fields: fields, tags: tags })
+      def update_note_fields(id, fields:, media: nil)
+        note = { id: id, fields: fields }
+        merge_media!(note, media) unless media.nil?
+        request(:updateNoteFields, note: note)
+      end
+
+      # Replaces all tags on a note.
+      #
+      # @param id [Integer] Note ID
+      # @param tags [String, Array<String>] Replacement tags
+      # @return [nil]
+      def update_note_tags(id, tags)
+        request(:updateNoteTags, note: id, tags: normalize_note_tags(tags))
+      end
+
+      # Changes a note's note type.
+      #
+      # @param id [Integer] Note ID
+      # @param note_type_name [String] New note type name
+      # All fields not supplied are cleared when the note type changes.
+      #
+      # @param fields [Hash] Complete values for fields in the new note type
+      # @param tags [Array<String>] Replacement tags
+      # @return [nil]
+      def change_note_type(id, note_type_name:, fields:, tags:)
+        request(:updateNoteModel, note: { id: id, modelName: note_type_name, fields: fields, tags: tags })
       end
 
       # Gets tags for a note.
       #
       # @param note_id [Integer] Note ID
       # @return [Array<String>] Array of tag strings
-      def get_note_tags(note_id)
+      def note_tags(note_id)
         request(:getNoteTags, note: note_id)
       end
 
@@ -81,7 +129,7 @@ module AnkiConnect
       # @param tags [String, Array<String>] Tag(s) to add
       # @return [nil]
       def add_tags(note_ids, tags)
-        request(:addTags, notes: note_ids, tags: tags)
+        request(:addTags, notes: note_ids, tags: normalize_tag_query(tags))
       end
 
       # Removes tags from notes.
@@ -90,13 +138,13 @@ module AnkiConnect
       # @param tags [String, Array<String>] Tag(s) to remove
       # @return [nil]
       def remove_tags(note_ids, tags)
-        request(:removeTags, notes: note_ids, tags: tags)
+        request(:removeTags, notes: note_ids, tags: normalize_tag_query(tags))
       end
 
       # Gets all tags in collection.
       #
       # @return [Array<String>] Array of all tag strings
-      def all_tags
+      def tags
         request(:getTags)
       end
 
@@ -134,10 +182,12 @@ module AnkiConnect
       # @param note_ids [Array<Integer>, nil] Array of note IDs
       # @param query [String, nil] Search query string
       # @return [Array<Hash>] Array of note objects
-      def get_notes(note_ids: nil, query: nil)
-        params = {}
-        params[:notes] = note_ids if note_ids
-        params[:query] = query if query
+      def notes(note_ids: nil, query: nil)
+        unless [note_ids, query].count { |selector| !selector.nil? } == 1
+          raise ArgumentError, 'provide exactly one of note_ids or query'
+        end
+
+        params = note_ids.nil? ? { query: query } : { notes: note_ids }
         request(:notesInfo, **params)
       end
 
@@ -145,7 +195,7 @@ module AnkiConnect
       #
       # @param note_ids [Array<Integer>] Array of note IDs
       # @return [Array<Hash>] Array of objects with noteId and mod
-      def get_notes_mod_time(note_ids)
+      def note_modification_times(note_ids)
         request(:notesModTime, notes: note_ids)
       end
 
@@ -157,12 +207,110 @@ module AnkiConnect
         request(:deleteNotes, notes: note_ids)
       end
 
-      # Removes all empty notes.
+      # Removes note types that are not used by any notes.
+      # The upstream action name is misleading; it does not remove notes with empty fields.
       #
       # @return [nil]
-      def remove_empty_notes
+      def remove_unused_note_types
         request(:removeEmptyNotes)
       end
+
+      private
+
+      NOTE_KEYS = {
+        'deck_name' => :deckName,
+        'note_type_name' => :modelName,
+        'fields' => :fields,
+        'tags' => :tags,
+        'options' => :options,
+        'media' => :media,
+        'audio' => :audio,
+        'video' => :video,
+        'picture' => :picture
+      }.freeze
+      GUI_NOTE_KEYS = NOTE_KEYS.reject { |key, _value| key == 'options' }.freeze
+      MEDIA_KEYS = {
+        'audio' => :audio,
+        'video' => :video,
+        'picture' => :picture
+      }.freeze
+      OPTION_KEYS = {
+        'allow_duplicate' => :allowDuplicate,
+        'duplicate_scope' => :duplicateScope,
+        'duplicate_scope_options' => :duplicateScopeOptions
+      }.freeze
+      SCOPE_OPTION_KEYS = {
+        'deck_name' => :deckName,
+        'check_children' => :checkChildren,
+        'check_all_note_types' => :checkAllModels
+      }.freeze
+      MEDIA_ITEM_KEYS = {
+        'filename' => :filename,
+        'fields' => :fields,
+        'data' => :data,
+        'path' => :path,
+        'url' => :url,
+        'skip_hash' => :skipHash,
+        'overwrite' => :deleteExisting
+      }.freeze
+      private_constant :NOTE_KEYS, :GUI_NOTE_KEYS, :MEDIA_KEYS, :OPTION_KEYS, :SCOPE_OPTION_KEYS, :MEDIA_ITEM_KEYS
+
+      def normalize_note(note, key_map: NOTE_KEYS)
+        normalized = normalize_keys(note, key_map, name: 'note') do |key, value|
+          if key == :options
+            normalize_options(value)
+          elsif MEDIA_KEYS.value?(key)
+            normalize_media(value)
+          else
+            value
+          end
+        end
+
+        merge_media!(normalized, normalized.delete(:media)) if normalized.key?(:media)
+        normalized
+      end
+
+      def normalize_gui_note(note)
+        normalize_note(note, key_map: GUI_NOTE_KEYS)
+      end
+
+      def merge_media!(note, media)
+        normalized_media = normalize_keys(media, MEDIA_KEYS, name: 'media') do |_key, value|
+          normalize_media(value)
+        end
+        normalized_media.each do |key, value|
+          raise ArgumentError, "duplicate media key: #{key}" if note.key?(key)
+
+          note[key] = value
+        end
+      end
+
+      def normalize_note_tags(tags)
+        tags = [tags] if tags.is_a?(String)
+        unless tags.is_a?(Array) && tags.all? { |tag| tag.is_a?(String) }
+          raise ArgumentError, 'tags must be a String or an Array of Strings'
+        end
+
+        tags
+      end
+
+      def normalize_tag_query(tags)
+        normalize_note_tags(tags).join(' ')
+      end
+
+      def normalize_options(options)
+        normalize_keys(options, OPTION_KEYS, name: 'options') do |key, value|
+          key == :duplicateScopeOptions ? normalize_keys(value, SCOPE_OPTION_KEYS, name: 'duplicate_scope_options') : value
+        end
+      end
+
+      def normalize_media(media)
+        media.is_a?(Array) ? media.map { |item| normalize_media_item(item) } : normalize_media_item(media)
+      end
+
+      def normalize_media_item(item)
+        normalize_keys(item, MEDIA_ITEM_KEYS, name: 'media item')
+      end
     end
   end
 end

data/lib/anki_connect/params.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module AnkiConnect
+  class Client
+    # Shared normalization for snake_case convenience inputs.
+    module Params
+      private
+
+      def normalize_keys(hash, key_map, name: 'parameters')
+        raise ArgumentError, "#{name} must be a Hash" unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), normalized|
+          normalized_key = key_map[key.to_s]
+          raise ArgumentError, "unknown #{name} key: #{key}" unless normalized_key
+          raise ArgumentError, "duplicate #{name} key: #{normalized_key}" if normalized.key?(normalized_key)
+
+          normalized[normalized_key] = block_given? ? yield(normalized_key, value) : value
+        end
+      end
+    end
+  end
+end

data/lib/anki_connect/statistics.rb

@@ -28,12 +28,12 @@ module AnkiConnect
         request(:getCollectionStatsHTML, wholeCollection: whole_collection)
       end
 
-      # Gets all card reviews for a deck after a certain time.
+      # Gets all card reviews for a deck after a review log ID.
       #
       # @param deck_name [String] Deck name
-      # @param after [Integer] Unix timestamp (reviews after this time, exclusive)
+      # @param after [Integer] Review log ID in epoch milliseconds (exclusive)
       # @return [Array<Array>] Array of 9-tuples: (reviewTime, cardID, usn, buttonPressed, newInterval, previousInterval, newFactor, reviewDuration, reviewType)
-      def get_reviews(deck_name, after:)
+      def reviews(deck_name, after:)
         request(:cardReviews, deck: deck_name, startID: after)
       end
 
@@ -41,21 +41,21 @@ module AnkiConnect
       #
       # @param card_ids [Array<Integer>] Array of card IDs
       # @return [Hash] Dictionary mapping card IDs to arrays of review objects with id, usn, ease, ivl, lastIvl, factor, time, type
-      def get_reviews_for_cards(card_ids)
+      def reviews_for_cards(card_ids)
         request(:getReviewsOfCards, cards: card_ids)
       end
 
-      # Gets unix time of latest review for a deck.
+      # Gets the latest review log ID for a deck.
       #
       # @param deck_name [String] Deck name
-      # @return [Integer] Unix timestamp, or 0 if no reviews
-      def latest_review_time(deck_name)
+      # @return [Integer] Review log ID in epoch milliseconds, or 0 if no reviews
+      def latest_review_id(deck_name)
         request(:getLatestReviewID, deck: deck_name)
       end
 
       # Inserts review records into database.
       #
-      # @param reviews [Array<Array>] Array of 9-tuples (same format as get_reviews output)
+      # @param reviews [Array<Array>] Array of 9-tuples (same format as reviews output)
       # @return [nil]
       def insert_reviews(reviews)
         request(:insertReviews, reviews: reviews)

data/lib/anki_connect/version.rb

@@ -2,7 +2,7 @@
 
 module AnkiConnect
   # The version of the anki_connect gem
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 
   # The AnkiConnect API version this gem is compatible with
   API_VERSION = 6

data/lib/anki_connect.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require_relative 'anki_connect/version'
+require_relative 'anki_connect/params'
 require_relative 'anki_connect/cards'
 require_relative 'anki_connect/decks'
-require_relative 'anki_connect/models'
+require_relative 'anki_connect/note_types'
 require_relative 'anki_connect/notes'
 require_relative 'anki_connect/media'
 require_relative 'anki_connect/graphical'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: anki_connect
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - vadik49b
@@ -17,8 +17,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
+- examples/add_elevenlabs_tts_audio_to_cloze_cards.rb
+- examples/basic_usage.rb
 - lib/anki_connect.rb
 - lib/anki_connect/cards.rb
 - lib/anki_connect/client.rb
@@ -26,8 +29,9 @@ files:
 - lib/anki_connect/graphical.rb
 - lib/anki_connect/media.rb
 - lib/anki_connect/miscellaneous.rb
-- lib/anki_connect/models.rb
+- lib/anki_connect/note_types.rb
 - lib/anki_connect/notes.rb
+- lib/anki_connect/params.rb
 - lib/anki_connect/statistics.rb
 - lib/anki_connect/version.rb
 homepage: https://github.com/vadik49b/anki-connect.rb
@@ -35,7 +39,11 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/vadik49b/anki-connect.rb
-  source_code_uri: https://github.com/vadik49b/anki-connect.rb
+  source_code_uri: https://github.com/vadik49b/anki-connect.rb/tree/main
+  documentation_uri: https://rubydoc.info/gems/anki_connect
+  bug_tracker_uri: https://github.com/vadik49b/anki-connect.rb/issues
+  changelog_uri: https://github.com/vadik49b/anki-connect.rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -50,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Ruby wrapper for the Anki-Connect HTTP API
 test_files: []

data/lib/anki_connect/models.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-module AnkiConnect
-  class Client
-    # Methods to create and modify note types (models).
-    module Models
-      # Gets complete list of model names.
-      #
-      # @return [Array<String>] Array of model name strings
-      def model_names
-        request(:modelNames)
-      end
-
-      # Gets model names with their IDs.
-      #
-      # @return [Hash] Model names mapped to IDs
-      def model_names_and_ids
-        request(:modelNamesAndIds)
-      end
-
-      # Gets models by ID.
-      #
-      # @param ids [Array<Integer>] Array of model IDs
-      # @return [Array<Hash>] Array of model objects
-      def get_models_by_id(ids)
-        request(:findModelsById, modelIds: ids)
-      end
-
-      # Gets models by name.
-      #
-      # @param names [Array<String>] Array of model names
-      # @return [Array<Hash>] Array of model objects
-      def get_models_by_name(names)
-        request(:findModelsByName, modelNames: names)
-      end
-
-      # Gets field names for a model.
-      #
-      # @param model_name [String] Model name
-      # @return [Array<String>] Array of field names in order
-      def get_field_names(model_name)
-        request(:modelFieldNames, modelName: model_name)
-      end
-
-      # Gets field descriptions for a model.
-      #
-      # @param model_name [String] Model name
-      # @return [Array<String>] Array of description strings
-      def get_field_descriptions(model_name)
-        request(:modelFieldDescriptions, modelName: model_name)
-      end
-
-      # Gets field fonts and sizes for a model.
-      #
-      # @param model_name [String] Model name
-      # @return [Hash] Field names mapped to { font:, size: }
-      def get_field_fonts(model_name)
-        request(:modelFieldFonts, modelName: model_name)
-      end
-
-      # Gets fields used on templates.
-      #
-      # @param model_name [String] Model name
-      # @return [Hash] Template names mapped to [questionFields, answerFields]
-      def get_fields_on_templates(model_name)
-        request(:modelFieldsOnTemplates, modelName: model_name)
-      end
-
-      # Creates a new model.
-      #
-      # @param name [String] Model name
-      # @param fields [Array<String>] Field names in order
-      # @param templates [Array<Hash>] Template objects with Name, Front, Back
-      # @param css [String, nil] CSS styling
-      # @param is_cloze [Boolean] true for cloze type
-      # @return [Hash] Complete model object
-      def create_model(name:, fields:, templates:, css: nil, is_cloze: false)
-        params = { modelName: name, inOrderFields: fields, cardTemplates: templates, isCloze: is_cloze }
-        params[:css] = css if css
-        request(:createModel, **params)
-      end
-
-      # Gets templates for a model.
-      #
-      # @param model_name [String] Model name
-      # @return [Hash] Template names mapped to { Front:, Back: }
-      def get_templates(model_name)
-        request(:modelTemplates, modelName: model_name)
-      end
-
-      # Gets CSS styling for a model.
-      #
-      # @param model_name [String] Model name
-      # @return [Hash] Object with css property
-      def get_styling(model_name)
-        request(:modelStyling, modelName: model_name)
-      end
-
-      # Updates a model's templates and/or CSS.
-      #
-      # @param name [String] Model name
-      # @param templates [Hash, nil] Template names mapped to Front/Back
-      # @param css [String, nil] CSS styling
-      # @return [nil]
-      def update_model(name, templates: nil, css: nil)
-        request(:updateModelTemplates, model: { name: name, templates: templates }) if templates
-        return unless css
-
-        request(:updateModelStyling, model: { name: name, css: css })
-      end
-
-      # Find and replace in model templates/CSS.
-      #
-      # @param model_name [String] Model name
-      # @param find [String] Text to find
-      # @param replace [String] Replacement text
-      # @param front [Boolean] Search front templates
-      # @param back [Boolean] Search back templates
-      # @param css [Boolean] Search CSS
-      # @return [Integer] Number of replacements made
-      def find_and_replace_in_model(model_name:, find:, replace:, front: true, back: true, css: true)
-        request(:findAndReplaceInModels, model: {
-                  modelName: model_name, findText: find, replaceText: replace,
-                  front: front, back: back, css: css
-                })
-      end
-
-      # Renames a template.
-      #
-      # @param model_name [String] Model name
-      # @param from [String] Current template name
-      # @param to [String] New template name
-      # @return [nil]
-      def rename_template(model_name, from:, to:)
-        request(:modelTemplateRename, modelName: model_name, oldTemplateName: from, newTemplateName: to)
-      end
-
-      # Moves a template to a new position.
-      #
-      # @param model_name [String] Model name
-      # @param template_name [String] Template name
-      # @param index [Integer] New position (0-based)
-      # @return [nil]
-      def reposition_template(model_name, template_name, index)
-        request(:modelTemplateReposition, modelName: model_name, templateName: template_name, index: index)
-      end
-
-      # Adds a template to a model.
-      #
-      # @param model_name [String] Model name
-      # @param template [Hash] Template with Name, Front, Back
-      # @return [nil]
-      def add_template(model_name, template)
-        request(:modelTemplateAdd, modelName: model_name, template: template)
-      end
-
-      # Removes a template from a model.
-      #
-      # @param model_name [String] Model name
-      # @param template_name [String] Template name
-      # @return [nil]
-      def remove_template(model_name, template_name)
-        request(:modelTemplateRemove, modelName: model_name, templateName: template_name)
-      end
-
-      # Renames a field.
-      #
-      # @param model_name [String] Model name
-      # @param from [String] Current field name
-      # @param to [String] New field name
-      # @return [nil]
-      def rename_field(model_name, from:, to:)
-        request(:modelFieldRename, modelName: model_name, oldFieldName: from, newFieldName: to)
-      end
-
-      # Moves a field to a new position.
-      #
-      # @param model_name [String] Model name
-      # @param field_name [String] Field name
-      # @param index [Integer] New position (0-based)
-      # @return [nil]
-      def reposition_field(model_name, field_name, index)
-        request(:modelFieldReposition, modelName: model_name, fieldName: field_name, index: index)
-      end
-
-      # Adds a field to a model.
-      #
-      # @param model_name [String] Model name
-      # @param field_name [String] Field name
-      # @param index [Integer, nil] Position (defaults to end)
-      # @return [nil]
-      def add_field(model_name, field_name, index: nil)
-        params = { modelName: model_name, fieldName: field_name }
-        params[:index] = index if index
-        request(:modelFieldAdd, **params)
-      end
-
-      # Removes a field from a model.
-      #
-      # @param model_name [String] Model name
-      # @param field_name [String] Field name
-      # @return [nil]
-      def remove_field(model_name, field_name)
-        request(:modelFieldRemove, modelName: model_name, fieldName: field_name)
-      end
-
-      # Sets font for a field.
-      #
-      # @param model_name [String] Model name
-      # @param field_name [String] Field name
-      # @param font [String] Font name
-      # @return [nil]
-      def set_field_font(model_name, field_name, font)
-        request(:modelFieldSetFont, modelName: model_name, fieldName: field_name, font: font)
-      end
-
-      # Sets font size for a field.
-      #
-      # @param model_name [String] Model name
-      # @param field_name [String] Field name
-      # @param size [Integer] Font size
-      # @return [nil]
-      def set_field_font_size(model_name, field_name, size)
-        request(:modelFieldSetFontSize, modelName: model_name, fieldName: field_name, fontSize: size)
-      end
-
-      # Sets description for a field.
-      #
-      # @param model_name [String] Model name
-      # @param field_name [String] Field name
-      # @param description [String] Description text
-      # @return [Boolean] true on success
-      def set_field_description(model_name, field_name, description)
-        request(:modelFieldSetDescription, modelName: model_name, fieldName: field_name, description: description)
-      end
-    end
-  end
-end