uploadcare-ruby 5.0.0 → 5.1.0

data/lib/uploadcare/api/rest.rb

@@ -5,7 +5,7 @@ require 'uri'
 
 # Base client for the Uploadcare REST API.
 #
-# Provides authenticated HTTP methods (GET, POST, PUT, DELETE) for all REST API
+# Provides authenticated HTTP methods (GET, POST, PUT, PATCH, DELETE) for all REST API
 # endpoints. Includes automatic error handling and throttle retry logic.
 #
 # Endpoint classes are accessed via lazy-loaded accessors:
@@ -71,6 +71,11 @@ class Uploadcare::Api::Rest
     memoized(:@file_metadata) { Uploadcare::Api::Rest::FileMetadata.new(rest: self) }
   end
 
+  # @return [Uploadcare::Api::Rest::FileTags] Per-file tag operations endpoint
+  def file_tags
+    memoized(:@file_tags) { Uploadcare::Api::Rest::FileTags.new(rest: self) }
+  end
+
   # @return [Uploadcare::Api::Rest::Addons] Add-on operations endpoint
   def addons
     memoized(:@addons) { Uploadcare::Api::Rest::Addons.new(rest: self) }
@@ -90,17 +95,18 @@ class Uploadcare::Api::Rest
 
   # Make an HTTP request to the REST API.
   #
-  # @param method [Symbol] HTTP method (:get, :post, :put, :delete)
+  # @param method [Symbol] HTTP method (:get, :post, :put, :patch, :delete)
   # @param path [String] API endpoint path
   # @param params [Hash, Array, String] Request parameters
+  # @param query [Hash] Query parameters for requests that also have a body
   # @param headers [Hash] Additional request headers
   # @param request_options [Hash] Request options (timeout, etc.)
   # @return [Hash, Array, nil] Parsed JSON response body
   # @raise [Uploadcare::Exception::RequestError] on API errors
-  def make_request(method:, path:, params: {}, headers: {}, request_options: {})
+  def make_request(method:, path:, params: {}, query: {}, headers: {}, request_options: {})
     handle_throttling(max_attempts: request_options[:max_throttle_attempts]) do
       response = connection.public_send(method, path) do |req|
-        prepare_request(req, method, path, params, headers, request_options)
+        prepare_request(req, method, path, params, query, headers, request_options)
       end
       response.body
     end
@@ -112,11 +118,14 @@ class Uploadcare::Api::Rest
   #
   # @param path [String] API endpoint path
   # @param params [Hash] Request body parameters
+  # @param query [Hash] Query parameters
   # @param headers [Hash] Additional request headers
   # @param request_options [Hash] Request options
   # @return [Uploadcare::Result]
-  def post(path:, params: {}, headers: {}, request_options: {})
-    request(method: :post, path: path, params: params, headers: headers, request_options: request_options)
+  def post(path:, params: {}, query: {}, headers: {}, request_options: {})
+    request(
+      method: :post, path: path, params: params, query: query, headers: headers, request_options: request_options
+    )
   end
 
   # Make a GET request wrapped in a Result.
@@ -141,6 +150,17 @@ class Uploadcare::Api::Rest
     request(method: :put, path: path, params: params, headers: headers, request_options: request_options)
   end
 
+  # Make a PATCH request wrapped in a Result.
+  #
+  # @param path [String] API endpoint path
+  # @param params [Hash] Request body parameters
+  # @param headers [Hash] Additional request headers
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  def patch(path:, params: {}, headers: {}, request_options: {})
+    request(method: :patch, path: path, params: params, headers: headers, request_options: request_options)
+  end
+
   # Make a DELETE request wrapped in a Result.
   #
   # @param path [String] API endpoint path
@@ -157,28 +177,33 @@ class Uploadcare::Api::Rest
   # @param method [Symbol] HTTP method
   # @param path [String] API path
   # @param params [Hash] Request parameters
+  # @param query [Hash] Query parameters for requests that also have a body
   # @param headers [Hash] Request headers
   # @param request_options [Hash] Request options
   # @return [Uploadcare::Result]
-  def request(method:, path:, params: {}, headers: {}, request_options: {})
+  def request(method:, path:, params: {}, query: {}, headers: {}, request_options: {})
     Uploadcare::Result.capture do
-      make_request(method: method, path: path, params: params, headers: headers, request_options: request_options)
+      make_request(
+        method: method, path: path, params: params, query: query, headers: headers, request_options: request_options
+      )
     end
   end
 
   private
 
-  def prepare_request(req, method, path, params, headers, request_options)
+  def prepare_request(req, method, path, params, query, headers, request_options)
     upcase_method_name = method.to_s.upcase
-    uri = build_request_uri(path, params, upcase_method_name)
+    query_params = upcase_method_name == HTTP_GET ? params : query
+    uri = build_request_uri(path, query_params)
 
     prepare_headers(req, upcase_method_name, uri, params, headers)
     prepare_body_or_params(req, upcase_method_name, params)
+    req.params.update(query) if upcase_method_name != HTTP_GET && !query.nil? && !query.empty?
     apply_request_options(req, request_options)
   end
 
-  def build_request_uri(path, params, method)
-    if method == HTTP_GET && !params.nil? && params.is_a?(Hash) && !params.empty?
+  def build_request_uri(path, params)
+    if !params.nil? && params.is_a?(Hash) && !params.empty?
       build_uri(path, params)
     else
       path

data/lib/uploadcare/api/upload/files.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Upload API endpoint for file upload operations.
-# rubocop:disable Metrics/ClassLength
+# rubocop:disable-next Metrics/ClassLength
 class Uploadcare::Api::Upload::Files
   # @return [Uploadcare::Api::Upload] Parent Upload client
   attr_reader :upload
@@ -14,7 +14,7 @@ class Uploadcare::Api::Upload::Files
   # Upload a file directly (POST /base/).
   #
   # @param file [File, IO] File object to upload
-  # @param options [Hash] Upload options (:store, :metadata, :signature, :expire)
+  # @param options [Hash] Upload options (:store, :metadata, :tags, :signature, :expire)
   # @param request_options [Hash] Request options
   # @return [Uploadcare::Result] Upload response with file UUID
   # @raise [ArgumentError] if file is not a valid IO object
@@ -32,7 +32,7 @@ class Uploadcare::Api::Upload::Files
   # Upload multiple files directly (POST /base/).
   #
   # @param files [Array<File, IO>] Files to upload
-  # @param options [Hash] Upload options (:store, :metadata)
+  # @param options [Hash] Upload options (:store, :metadata, :tags)
   # @param request_options [Hash] Request options
   # @return [Uploadcare::Result] Upload response hash mapping filenames to UUIDs
   # @see https://uploadcare.com/api-refs/upload-api/#operation/baseUpload
@@ -63,6 +63,7 @@ class Uploadcare::Api::Upload::Files
   # @option options [Boolean] :async Return immediately with token (default: false)
   # @option options [String, Boolean] :store Whether to store the file
   # @option options [Hash] :metadata Custom metadata
+  # @option options [Array<String>] :tags Tags to attach to the file
   # @option options [Integer] :poll_interval Polling interval in seconds (default: 1)
   # @option options [Integer] :poll_timeout Max polling time in seconds (default: 300)
   # @param request_options [Hash] Request options
@@ -105,7 +106,7 @@ class Uploadcare::Api::Upload::Files
   # @param filename [String] Original filename
   # @param size [Integer] File size in bytes
   # @param content_type [String] MIME type
-  # @param options [Hash] Upload options (:store, :metadata)
+  # @param options [Hash] Upload options (:store, :metadata, :tags)
   # @param request_options [Hash] Request options
   # @return [Uploadcare::Result] Response with UUID and presigned URLs
   # @see https://uploadcare.com/api-refs/upload-api/#operation/multipartUploadStart
@@ -198,6 +199,8 @@ class Uploadcare::Api::Upload::Files
     params['save_URL_duplicates'] = options[:save_URL_duplicates].to_s if options.key?(:save_URL_duplicates)
     metadata_params = generate_metadata_params(options[:metadata])
     params.merge!(metadata_params) if metadata_params.any?
+    tags_param = generate_tags_param(options[:tags])
+    params.merge!(tags_param) if tags_param.any?
     params.merge!(signature_params(options))
     params
   end
@@ -213,6 +216,8 @@ class Uploadcare::Api::Upload::Files
     params['UPLOADCARE_STORE'] = store unless store.nil?
     metadata_params = generate_metadata_params(options[:metadata])
     params.merge!(metadata_params) if metadata_params.any?
+    tags_param = generate_tags_param(options[:tags])
+    params.merge!(tags_param) if tags_param.any?
     params.merge!(signature_params(options))
     params
   end
@@ -270,6 +275,15 @@ class Uploadcare::Api::Upload::Files
     end
   end
 
+  def generate_tags_param(tags = nil)
+    return {} if tags.nil?
+
+    normalized = Uploadcare::Internal::FileTagNormalizer.call(tags)
+    return {} if normalized.empty?
+
+    { 'tags' => normalized.join(',') }
+  end
+
   def signature_params(options = {})
     return {} if options.nil?
 
@@ -310,4 +324,3 @@ class Uploadcare::Api::Upload::Files
     [initial.to_f * (2**attempt), max_interval.to_f].min
   end
 end
-# rubocop:enable Metrics/ClassLength

data/lib/uploadcare/api/upload.rb

@@ -159,7 +159,7 @@ class Uploadcare::Api::Upload
   end
 
   def prepare_headers(req, _method, _uri, headers)
-    req.headers['User-Agent'] ||= Uploadcare::Internal::UserAgent.call(config: config)
+    req.headers['User-Agent'] = Uploadcare::Internal::UserAgent.call(config: config)
     req.headers.merge!(headers)
   end
 
@@ -243,6 +243,7 @@ class Uploadcare::Api::Upload
   def upload_part_request(conn:, request_uri:, data:, timeout:, open_timeout:)
     conn.put(request_uri) do |req|
       req.headers['Content-Type'] = 'application/octet-stream'
+      req.headers['User-Agent'] = Uploadcare::Internal::UserAgent.call(config: config)
       req.options.timeout = timeout if timeout
       req.options.open_timeout = open_timeout if open_timeout
       req.body = data

data/lib/uploadcare/client/file_tags_accessor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Per-file tag operations scoped to a client instance.
+#
+# @example Replace and update tags
+#   client.file_tags.replace(uuid: file.uuid, tags: %w[approved summer])
+#   client.file_tags.update(uuid: file.uuid, add: ["featured"], delete: ["summer"])
+class Uploadcare::Client::FileTagsAccessor
+  attr_reader :client
+
+  # @param client [Uploadcare::Client]
+  def initialize(client:)
+    @client = client
+  end
+
+  # @param uuid [String]
+  # @param request_options [Hash]
+  # @return [Array<String>]
+  def list(uuid:, request_options: {})
+    Uploadcare::Resources::FileTags.list(uuid: uuid, client: client, request_options: request_options)
+  end
+  alias index list
+
+  # @param uuid [String]
+  # @param tags [Array<String>]
+  # @param request_options [Hash]
+  # @return [Uploadcare::Resources::FileTags]
+  def replace(uuid:, tags:, request_options: {})
+    Uploadcare::Resources::FileTags.replace(
+      uuid: uuid, tags: tags, client: client, request_options: request_options
+    )
+  end
+
+  # @param uuid [String]
+  # @param add [Array<String>]
+  # @param delete [Array<String>]
+  # @param request_options [Hash]
+  # @return [Uploadcare::Resources::FileTags]
+  def update(uuid:, add: [], delete: [], request_options: {})
+    Uploadcare::Resources::FileTags.update(
+      uuid: uuid, add: add, delete: delete, client: client, request_options: request_options
+    )
+  end
+end

data/lib/uploadcare/client/files_accessor.rb

@@ -28,6 +28,23 @@ class Uploadcare::Client::FilesAccessor
     )
   end
 
+  # Search files using full-text criteria and structured filters.
+  #
+  # @example Search PDFs and inspect highlighted matches
+  #   results = client.files.search(
+  #     query: "invoice", exact: { detected_mime_type: ["application/pdf"] }, limit: 20
+  #   )
+  #   results.each { |file| puts file.highlight }
+  #
+  # @param request_options [Hash]
+  # @param options [Hash] Search criteria plus limit, offset, and include
+  # @return [Uploadcare::Collections::FileSearchResult]
+  def search(request_options: {}, **options)
+    Uploadcare::Resources::File.search(
+      options: options, client: client, request_options: request_options
+    )
+  end
+
   # @param source [IO, Array<IO>, String]
   # @param request_options [Hash]
   # @param options [Hash]

data/lib/uploadcare/client.rb

@@ -96,6 +96,13 @@ class Uploadcare::Client
     memoized(:@file_metadata) { FileMetadataAccessor.new(client: self) }
   end
 
+  # Access per-file tag operations.
+  #
+  # @return [Uploadcare::Client::FileTagsAccessor]
+  def file_tags
+    memoized(:@file_tags) { FileTagsAccessor.new(client: self) }
+  end
+
   # Access conversion helpers.
   #
   # @return [Uploadcare::Client::ConversionsAccessor]

data/lib/uploadcare/collections/file_search_result.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Paginated results returned by the file search endpoint.
+#
+# Search pagination uses POST requests, so every subsequent page must resend the
+# original JSON search criteria while following the query parameters supplied by
+# the API's next or previous URL.
+class Uploadcare::Collections::FileSearchResult < Uploadcare::Collections::Paginated
+  # @return [Hash] JSON search criteria resent for subsequent pages
+  attr_reader :search_params, :search_query
+
+  def initialize(params = {})
+    @search_params = immutable_copy(params[:search_params] || {})
+    @search_query = immutable_copy(params[:search_query] || {})
+    super
+  end
+
+  private
+
+  def immutable_copy(value)
+    case value
+    when Hash
+      value.each_with_object({}) do |(key, nested_value), copy|
+        copy[immutable_copy(key)] = immutable_copy(nested_value)
+      end.freeze
+    when Array
+      value.map { |nested_value| immutable_copy(nested_value) }.freeze
+    when String
+      value.dup.freeze
+    else
+      value
+    end
+  end
+
+  def fetch_response(params)
+    query = search_query.transform_keys(&:to_s).merge(params)
+    Uploadcare::Result.unwrap(
+      api_client.search(params: search_params, query: query, request_options: request_options)
+    )
+  end
+
+  def continuation_options
+    { search_params: search_params, search_query: search_query }
+  end
+end

data/lib/uploadcare/collections/paginated.rb

@@ -155,10 +155,16 @@ class Uploadcare::Collections::Paginated
       api_client: api_client,
       resource_class: resource_class,
       client: client,
-      request_options: request_options
+      request_options: request_options,
+      **continuation_options
     )
   end
 
+  # Extra state that a specialized collection needs to carry to subsequent pages.
+  def continuation_options
+    {}
+  end
+
   def build_resources(results)
     results.map { |data| resource_class.new(data, client) }
   end

data/lib/uploadcare/internal/file_tag_normalizer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Normalizes and validates file tags before sending them to Uploadcare.
+class Uploadcare::Internal::FileTagNormalizer
+  MAX_LENGTH = 100
+  MAX_COUNT = 50
+  VALID_PATTERN = /\A[a-z0-9._-]+\z/
+
+  class << self
+    # Normalize a list of file tags.
+    #
+    # Tags are stripped, lowercased, and deduplicated while preserving their
+    # first-seen order.
+    #
+    # @param tags [Array<String>]
+    # @param max_count [Integer, nil] Maximum number of tags; nil disables the limit
+    # @return [Array<String>]
+    # @raise [ArgumentError] if a tag is invalid
+    def call(tags, max_count: MAX_COUNT)
+      raise ArgumentError, 'tags must be an array of strings' unless tags.is_a?(Array)
+
+      normalized = normalize(tags)
+      validate_count(normalized, max_count)
+      normalized
+    end
+
+    private
+
+    def normalize(tags)
+      seen = {}
+
+      tags.each_with_object([]) do |tag, result|
+        raise ArgumentError, 'tags must be an array of strings' unless tag.is_a?(String)
+
+        value = tag.strip.downcase
+        next if value.empty?
+
+        validate_tag(value)
+        next if seen[value]
+
+        seen[value] = true
+        result << value
+      end
+    end
+
+    def validate_tag(tag)
+      if tag.length > MAX_LENGTH
+        raise ArgumentError, "tag is too long: #{tag.length} characters (maximum #{MAX_LENGTH})"
+      end
+      return if VALID_PATTERN.match?(tag)
+
+      raise ArgumentError,
+            'tag contains invalid characters; allowed: Latin letters, digits, hyphen, underscore, dot'
+    end
+
+    def validate_count(tags, max_count)
+      return if max_count.nil? || max_count.zero? || tags.length <= max_count
+
+      raise ArgumentError, "too many tags: #{tags.length} (maximum #{max_count})"
+    end
+  end
+end

data/lib/uploadcare/internal/upload_params_generator.rb

@@ -3,12 +3,12 @@
 # Generates upload parameters for Upload API requests.
 #
 # Builds the parameter hash needed for file uploads, including public key,
-# store preferences, metadata, and optional signature params.
+# store preferences, metadata, tags, and optional signature params.
 class Uploadcare::Internal::UploadParamsGenerator
   class << self
     # Build upload parameters.
     #
-    # @param options [Hash] Upload options (:store, :metadata, :signature, :expire)
+    # @param options [Hash] Upload options (:store, :metadata, :tags, :signature, :expire)
     # @param config [Uploadcare::Configuration] Configuration with public key and signing settings
     # @return [Hash] Upload parameters hash
     def call(options: {}, config: Uploadcare.configuration)
@@ -20,6 +20,7 @@ class Uploadcare::Internal::UploadParamsGenerator
       params['UPLOADCARE_STORE'] = store unless store.nil?
 
       params.merge!(metadata(options: options))
+      params.merge!(tags(options: options))
       params.merge!(signature_params(options: options, config: config))
 
       params.compact
@@ -54,6 +55,19 @@ class Uploadcare::Internal::UploadParamsGenerator
       end
     end
 
+    # Generate the comma-separated tags parameter.
+    #
+    # @param options [Hash] Options containing :tags
+    # @return [Hash]
+    def tags(options:)
+      return {} if options[:tags].nil?
+
+      normalized = Uploadcare::Internal::FileTagNormalizer.call(options[:tags])
+      return {} if normalized.empty?
+
+      { 'tags' => normalized.join(',') }
+    end
+
     # Generate signature parameters for signed uploads.
     #
     # @param options [Hash] Options with optional :signature and :expire keys

data/lib/uploadcare/internal/user_agent.rb

@@ -7,7 +7,7 @@
 #
 # @example
 #   Uploadcare::Internal::UserAgent.call(config: config)
-#   # => "UploadcareRuby/5.0.0/demopublickey (Ruby/3.3.0)"
+#   # => "UploadcareRuby/5.1.0/demopublickey (Ruby/3.3.0)"
 class Uploadcare::Internal::UserAgent
   # Build a User-Agent string.
   #

data/lib/uploadcare/operations/file_search.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Executes a file search and builds its POST-aware paginated result.
+class Uploadcare::Operations::FileSearch
+  QUERY_OPTIONS = %i[limit offset include].freeze
+
+  class << self
+    def call(options:, client:, resource_class:, request_options: {})
+      search_params, query_params = split_options(options)
+      response = Uploadcare::Result.unwrap(
+        client.api.rest.files.search(
+          params: search_params, query: query_params, request_options: request_options
+        )
+      )
+
+      Uploadcare::Collections::FileSearchResult.new(
+        resources: response.fetch('results', []).map { |data| resource_class.new(data, client) },
+        next_page: response['next'],
+        previous_page: response['previous'],
+        per_page: response['per_page'],
+        total: response['total'],
+        api_client: client.api.rest.files,
+        resource_class: resource_class,
+        client: client,
+        request_options: request_options,
+        search_params: search_params,
+        search_query: query_params
+      )
+    end
+
+    private
+
+    def split_options(options)
+      body = options.dup
+      query = QUERY_OPTIONS.to_h do |key|
+        value = body.key?(key) ? body.delete(key) : body[key.to_s]
+        body.delete(key.to_s)
+        [key, value]
+      end
+      [body, query.compact]
+    end
+  end
+end

data/lib/uploadcare/operations/multipart_upload.rb

@@ -32,7 +32,7 @@ class Uploadcare::Operations::MultipartUpload
   # Execute the full multipart upload flow.
   #
   # @param file [File, IO] File to upload
-  # @param options [Hash] Upload options (:store, :metadata, :threads, :part_size)
+  # @param options [Hash] Upload options (:store, :metadata, :tags, :threads, :part_size)
   # @param request_options [Hash] Request options
   # @yield [Hash] Progress callback with :uploaded, :total, :part, :total_parts
   # @return [Uploadcare::Result] Result containing { 'uuid' => '...' }

data/lib/uploadcare/operations/upload_router.rb

@@ -31,7 +31,7 @@ class Uploadcare::Operations::UploadRouter
   # - Strings → URL upload
   #
   # @param source [File, IO, String, Array] Upload source
-  # @param options [Hash] Upload options (:store, :metadata, etc.)
+  # @param options [Hash] Upload options (:store, :metadata, :tags, etc.)
   # @param request_options [Hash] Request options
   # @return [Uploadcare::Resources::File, Array<Uploadcare::Resources::File>, Hash]
   # @raise [ArgumentError] if source type is not recognized
@@ -81,7 +81,7 @@ class Uploadcare::Operations::UploadRouter
   # Upload a file from URL.
   #
   # @param url [String] Source URL
-  # @param options [Hash] Upload options (:async, :store, :metadata)
+  # @param options [Hash] Upload options (:async, :store, :metadata, :tags)
   # @param request_options [Hash] Request options
   # @return [Uploadcare::Resources::File, Hash] File resource (sync) or token hash (async)
   def upload_from_url(url:, request_options: {}, **options)

data/lib/uploadcare/resources/file.rb

@@ -19,13 +19,13 @@ class Uploadcare::Resources::File < Uploadcare::Resources::BaseResource
   # API fields assigned onto file resources.
   ATTRIBUTES = %i[
     datetime_removed datetime_stored datetime_uploaded is_image is_ready mime_type original_file_url
-    original_filename size url uuid variations content_info metadata appdata source
+    original_filename size url uuid variations content_info metadata tags appdata source highlight
   ].freeze
 
   attr_writer :uuid
   attr_accessor :datetime_removed, :datetime_stored, :datetime_uploaded, :is_image, :is_ready, :mime_type,
                 :original_file_url, :original_filename, :size, :url, :variations, :content_info,
-                :metadata, :appdata, :source
+                :metadata, :tags, :appdata, :source, :highlight
 
   # --- Class methods ---
 
@@ -45,11 +45,6 @@ class Uploadcare::Resources::File < Uploadcare::Resources::BaseResource
     new(response, resolved_client)
   end
 
-  class << self
-    alias retrieve find
-    alias info find
-  end
-
   # List files with optional filtering and pagination.
   #
   # @param options [Hash] Query parameters (limit, ordering, etc.)
@@ -78,6 +73,23 @@ class Uploadcare::Resources::File < Uploadcare::Resources::BaseResource
     )
   end
 
+  # Search files with full-text criteria and structured filters.
+  #
+  # `limit`, `offset`, and `include` are sent as query parameters. All other
+  # options are sent in the JSON request body as search criteria.
+  #
+  # @param options [Hash] Search criteria plus pagination/expansion options
+  # @param client [Uploadcare::Client, nil] Client instance
+  # @param config [Uploadcare::Configuration] Configuration fallback
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Collections::FileSearchResult]
+  def self.search(options: {}, client: nil, config: Uploadcare.configuration, request_options: {})
+    resolved_client = resolve_client(client: client, config: config)
+    Uploadcare::Operations::FileSearch.call(
+      options: options, client: resolved_client, resource_class: self, request_options: request_options
+    )
+  end
+
   # Upload a single file.
   #
   # @param file [File, IO] File to upload
@@ -114,10 +126,6 @@ class Uploadcare::Resources::File < Uploadcare::Resources::BaseResource
     resolved_client.uploads.upload_from_url(url: url, request_options: request_options, **options)
   end
 
-  class << self
-    alias upload_from_url upload_url
-  end
-
   # Batch store files.
   #
   # @param uuids [Array<String>] File UUIDs to store
@@ -175,10 +183,6 @@ class Uploadcare::Resources::File < Uploadcare::Resources::BaseResource
     new(response['result'], resolved_client)
   end
 
-  class << self
-    alias copy_to_local local_copy
-  end
-
   # Copy a file to remote storage (class method).
   #
   # @param source [String] CDN URL or UUID
@@ -197,6 +201,10 @@ class Uploadcare::Resources::File < Uploadcare::Resources::BaseResource
   end
 
   class << self
+    alias retrieve find
+    alias info find
+    alias upload_from_url upload_url
+    alias copy_to_local local_copy
     alias copy_to_remote remote_copy
   end