ubiquity-iconik 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc41c044ba6d0e56d1e5a8197a8bdbfa4ec81c87
+  data.tar.gz: 782d648bbdfb20965044d5d472d4e28eaa5ba04f
+SHA512:
+  metadata.gz: 418e71c8b7ca452f6136e5f580e5f074e95ce8f348ced28c150f859bd12878c5d7b6a303107a24e700606443852c1ed7fd1a6e620ac3e2542e9f59e94d93bc6b
+  data.tar.gz: 6f78abc996e83b01053be5c2cefee120bddefaec0b5e84925091f649ed26ad076ead492bb1f51768b7c34c72cf0240f5c72e1005bad3e6af5cf730e3bfb1a7df

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/dev/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 1.8.7
+before_install: gem install bundler -v 1.14.0.pre.2

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'json', '~>1.8', :platforms => :mri_18
+
+# Specify your gem's dependencies in ubiquity-iconik.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 John Whitson
+
+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,41 @@
+# Ubiquity::Iconik
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ubiquity/iconik`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ubiquity-iconik'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ubiquity-iconik
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/John Whitson/ubiquity-iconik.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ubiquity/iconik'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+begin
+  require 'pry'
+  Pry.start
+rescue LoadError => e
+  require 'irb'
+  IRB.start(__FILE__)
+end
+

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/ubiquity-iconik

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'ubiquity/iconik'

data/lib/ubiquity/iconik.rb

@@ -0,0 +1,7 @@
+require 'ubiquity/iconik/version'
+
+module Ubiquity
+  module Iconik
+
+  end
+end

data/lib/ubiquity/iconik/api/client.rb

@@ -0,0 +1,708 @@
+require 'logger'
+require 'date'
+require 'yaml'
+
+require 'ubiquity/iconik/api/client/http_client'
+require 'ubiquity/iconik/api/client/requests'
+require 'ubiquity/iconik/api/client/paginator'
+
+module  Ubiquity
+  module Iconik
+    module API
+      class Client
+
+        attr_accessor :http_client, :request, :response, :logger
+
+        def initialize(args = { })
+          @http_client = HTTPClient.new(args)
+          @logger = http_client.logger
+
+        end
+
+        # Exposes HTTP Methods
+        # @example http(:get, '/')
+        def http(method, *args)
+          @request = nil
+          @response = http_client.send(method, *args)
+          @request = http_client.request
+          response
+        end
+
+        def paginator
+          @paginator ||= Paginator.new(self) if @response
+        end
+
+        def process_request(request, options = nil)
+          @paginator = nil
+          @response = nil
+          @request = request
+
+          logger.warn { "Request is Missing Required Arguments: #{request.missing_required_arguments.inspect}" } unless request.missing_required_arguments.empty?
+
+          if ([:all, 'all'].include?(request.arguments[:page]))
+            request.arguments[:page] = 1
+            include_remaining_pages = true
+          else
+            include_remaining_pages = false
+          end
+
+          request.client = self unless request.client
+          options ||= request.options
+          logger.warn { "Request is Missing Required Arguments: #{request.missing_required_arguments.inspect}" } unless request.missing_required_arguments.empty?
+
+          return (options.fetch(:return_request, true) ? request : nil) unless options.fetch(:execute_request, true)
+
+          #@response = http_client.call_method(request.http_method, { :path => request.path, :query => request.query, :body => request.body }, options)
+          @response = request.execute
+
+          if include_remaining_pages
+            return paginator.include_remaining_pages
+          end
+
+          @response
+        end
+
+        def process_request_using_class(request_class, args, options = { })
+          @response = nil
+          @request = request_class.new(args, options.merge(:client => self))
+          process_request(request, options)
+        end
+
+        # Tries to determine if the last request got a successful response
+        def success?
+          return unless @request
+          if @request.respond_to?(:success?)
+            @request.success?
+          else
+            _response = http_client.response
+            _response && _response.code.start_with?('2')
+          end
+        rescue => e
+          logger.error { "Exception executing method :success?. '#{e.message}'\n#{e.backtrace}" }
+          return false
+        end
+
+        # def success?
+        #   request && (request.respond_to?(:success?) ? request.success? : (response && response.code.start_with?('2')))
+        # end
+
+        # Will try to return the most concise error message possible
+        #
+        # Example:
+        # {
+        #   "invalidInput": {
+        #       "id": "portal_mf734147",
+        #       "context": "metadata-field",
+        #       "value": null,
+        #   "explanation": "The metadata value is invalid"
+        #   },
+        #   "conflict": null,
+        #   "notAuthorized": null,
+        #   "fileAlreadyExists": null,
+        #   "licenseFault": null,
+        #   "notFound": null,
+        #   "internalServer": null,
+        #   "forbidden": null,
+        #   "notYetImplemented": null
+        # }
+        #
+        # will become
+        #
+        # {
+        #   "invalidInput"=> {
+        #     "id"=>"portal_mf734147",
+        #     "context"=>"metadata-field",
+        #     "value"=>nil,
+        #     "explanation"=>"The metadata value is invalid"
+        #   }
+        # }
+        def error
+          _response_parsed = http_client.response_parsed
+          if _response_parsed.is_a?(Hash)
+            _error = _response_parsed.delete_if { |k,v| v.nil? }
+            _error
+          else
+            _response = http_client.response
+            _response.body if _response.respond_to?(:body)
+          end
+        end
+
+        # ############################################################################################################## #
+        # @!group API Endpoints
+
+        # Start a job that creates sends an asset to Google Cloud Video Intelligence API
+        #
+        # @see https://app.iconik.io/docs/apidocs.html?url=/docs/transcode/spec/
+        def asset_analyze(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'transcode/v1/analyze/assets/#{path_arguments[:asset_id]}/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :aliases => [ :id ], :required => true, :send_in => :path },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        # Create a new asset
+        #
+        # @see https://app.iconik.io/docs/apidocs.html?url=/docs/assets/spec/#/default/post_v1_assets_
+        def asset_create(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/assets/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_delete(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/assets/#{path_arguments[:asset_id]}/',
+              :http_method => :delete,
+              :http_success_code => '204',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :aliases => [ :id ], :required => true, :send_in => :path },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_download_url_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+              args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/files/#{path_arguments[:file_id]}/download_url/',
+              :parameters => [
+                { :name => :asset_id, :aliases => [ :id ], :required => true, :send_in => :path },
+                { :name => :file_id, :required => true, :send_in => :path }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_file_create(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/files/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+
+                { :name => :file_set_id, :required => true },
+                { :name => :file_date_create, :required => true },
+                { :name => :file_date_modified, :required => true },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_file_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/files/#{path_arguments[:file_id]}/',
+              :http_method => :get,
+              :http_success_code => '200',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :file_id, :aliases => [ :id ], :send_in => :path }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_file_update(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/files/#{path_arguments[:file_id]}/',
+              :http_method => :patch,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :file_id, :required => true, :send_in => :path },
+
+                { :name => :file_set_id, :required => true },
+                { :name => :file_date_create, :required => true },
+                { :name => :file_date_modified, :required => true },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_file_keyframes_create(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/files/#{path_arguments[:file_id]}/keyframes/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :file_id, :required => true, :send_in => :path },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_file_set_create(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/file_sets/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+        alias :asset_fileset_create :asset_file_set_create
+
+        def asset_files_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/files/',
+              :parameters => [
+                { :name => :asset_id, :aliases => [ :id ], :required => true, :send_in => :path },
+                { :name => :generate_signed_url, :send_in => :query }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_format_create(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/formats/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :name, :default_value => 'ORIGINAL' },
+                { :name => :metadata }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_format_file_sets_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/formats/#{path_arguments[:format_id]}/file_sets/',
+              :http_method => :get,
+              :http_success_code => '200',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :format_id, :aliases => [ :id ], :send_in => :path }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_format_file_sets_sources_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/formats/#{path_arguments[:format_id]}/file_sets/sources/',
+              :http_method => :get,
+              :http_success_code => '200',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :format_id, :aliases => [ :id ], :send_in => :path }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_format_get_by_name(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/formats/#{path_arguments[:format_name]}/',
+              :http_method => :get,
+              :http_success_code => '200',
+              :body => args,
+              :parameters => [
+                  { :name => :asset_id, :required => true, :send_in => :path },
+                  { :name => :format_name, :aliases => [ :name ], :send_in => :path }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def asset_formats_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/assets/#{path_arguments[:asset_id]}/formats/',
+              :http_method => :get,
+              :http_success_code => '200',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :name, :default_value => 'ORIGINAL' },
+                { :name => :metadata }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+
+        def asset_keyframes_get(args = { }, options = { })
+
+        end
+
+        def asset_metadata_set(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'metadata/v1/assets/#{path_arguments[:asset_id]}/views/#{path_arguments[:view_id]}/',
+              :http_method => :put,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :asset_id, :required => true, :send_in => :path },
+                { :name => :view_id, :required => true, :send_in => :path },
+                { :name => :metadata_values }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def assets_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/assets/',
+              :default_parameter_send_in_value => :query,
+              :parameters => [
+                { :name => :per_page },
+                { :name => :page },
+                { :name => :sort },
+                { :name => :filter }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def assets_reindex(args = { }, options = { })
+          http(:post, 'assets/v1/assets/reindex/')
+        end
+
+        # Login by using email and password
+        # @see https://app.iconik.io/docs/apidocs.html?url=/docs/auth/spec/#/default/post_v1_auth_simple_login_
+        def auth_login_simple(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'auth/v1/auth/simple/login/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :parameters => [
+                { :name => :email, :required => true },
+                { :name => :password, :required => true }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        # Check if auth token valid
+        # @see https://app.iconik.io/docs/apidocs.html?url=/docs/auth/spec/#/default/get_v1_auth_token_
+        # @deprecated
+        def auth_token_get(args = { }, options = { })
+          _token = args[:token] || token
+          _token = token.to_s if _token.respond_to?(:to_s)
+          http(:get, 'auth/v1/auth/token/', { :headers => { http_client.header_auth_key => _token } })
+        end
+
+        # Refresh token
+        # @see https://app.iconik.io/docs/apidocs.html?url=/docs/auth/spec/#/default/put_v1_auth_token_
+        # @deprecated
+        def auth_token_refresh(args = { }, options = { })
+          http(:put, 'auth/v1/auth/token/')
+        end
+
+        def collection_create(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/collections/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,  # Passthrough all arguments passed to the request body
+              :parameters => [
+                { :name => :title, :aliases => [:collection_title, :collection_name, :name ] },
+                { :name => :description },
+                { :name => :parent_id },
+                { :name => :is_root },
+                { :name => :date_created },
+                { :name => :description }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def collection_delete(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/collections/#{path_arguments[:collection_id]}/',
+              :http_method => :delete,
+              :http_success_code => '201',
+              :parameters => [
+                { :name => :collection_id, :aliases => [ :id ], :send_in => :path }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def collection_replace(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/collections/#{path_arguments[:collection_id]}/',
+              :http_method => :put,
+              :http_success_code => '200',
+              :parameters => [
+                { :name => :collection_id, :aliases => [ :id ], :send_in => :path },
+                { :name => :title, :aliases => [ :collection_title, :collection_name, :name ] },
+                { :name => :description },
+                { :name => :parent_id },
+                { :name => :is_root },
+                { :name => :date_created },
+                { :name => :description }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def collection_update(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/collections/#{path_arguments[:collection_id]}/',
+              :http_method => :patch,
+              :http_success_code => '200',
+              :parameters => [
+                { :name => :collection_id, :aliases => [ :id ], :send_in => :path },
+                { :name => :title, :aliases => [ :collection_title, :collection_name, :name ] },
+                { :name => :description },
+                { :name => :parent_id },
+                { :name => :is_root },
+                { :name => :date_created },
+                { :name => :description }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def collection_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/collections/#{arguments[:collection_id]}/',
+              :body => args,
+              :parameters => [
+                { :name => :collection_id }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def collection_content_add(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/collections/#{path_arguments[:collection_id]}/contents/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+                { :name => :collection_id, :send_in => :path },
+                { :name => :object_id },
+                { :name => :object_type },
+                { :name => :date_created },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+
+        def collection_contents_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'assets/v1/collections/#{path_arguments[:collection_id]}/contents/',
+              :parameters => [
+                { :name => :collection_id, :aliases => [ :id ], :send_in => :path },
+                { :name => :content_types }, # Comma separated list of content types. Example - assets,collections
+                { :name => :per_page },
+                { :name => :page },
+                { :name => :sort }, # A comma separated list of fieldnames with order. For example - first_name,asc;last_name,desc
+                { :name => :filter }, # A comma separated list of fieldnames with order For example - first_name,eq,Vlad;last_name,eq,Gudkov
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def collections_get(args = { }, options = { })
+          http(:get, 'assets/v1/collections/')
+        end
+
+        def collections_reindex(args = { }, options = { })
+          http(:post, 'assets/collections/reindex/')
+        end
+
+        def file_set_files_get(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/file_sets/#{path_arguments[:file_set_id]}/files/',
+              :parameters => [
+                { :name => :file_set_id, :aliases => [ :id ], :send_in => :path },
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def metadata_field_create(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/storages/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def storage_create(args = { }, options = { })
+          # http(:post, 'files/v1/storages/', args)
+
+          _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/storages/',
+              :http_method => :post,
+              :http_success_code => '201',
+              :body => args,
+              :parameters => [
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def storage_files_get(args = { }, options = { })
+         _request = Requests::BaseRequest.new(
+            args,
+            {
+              :http_path => 'files/v1/storages/#{path_arguments[:storage_id]}/files/',
+              :body => args,
+              :parameters => [
+                { :name => :storage_id, :required => true, :send_in => :path },
+                { :name => :path }
+              ]
+            }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        def storages_get(args = { }, options = { })
+          http(:get, 'files/v1/storages/')
+        end
+
+        def token
+          http_client.token
+        end
+
+        def token=(token_data)
+          http_client.token = token_data
+        end
+
+        def transcode(args = { }, options = { })
+          _request = Requests::BaseRequest.new(
+              args,
+              {
+                  :http_path => 'transcode/v1/transcode/',
+                  :http_method => :post,
+                  :http_success_code => '201',
+                  :parameters => [
+                  ]
+              }.merge(options)
+          )
+          process_request(_request, options)
+        end
+
+        # @!endgroup API Endpoints
+        # ############################################################################################################## #
+
+        # Client
+      end
+
+      # API
+    end
+
+    # Iconik
+  end
+
+  # Ubiquity
+end