pylon-api 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 417baee1f917bf76f2bebeafe9ac0e740ca238649225e26ad75092d368d542ef
-  data.tar.gz: '018b75c89e76821075e2c6a9a369ce2630627d82c15a441c162aa16de0d78a2e'
+  metadata.gz: 4f54f7ed75e823866e06256d1a598bb3158e686131156932b7aad3d9a90da9c7
+  data.tar.gz: fe68e2c1be8128acadd4179b2baa2751fd9223fdbe1a5c66cb35d2d41c13fae0
 SHA512:
-  metadata.gz: 658536c7d456207f7ff5eab110aa1f991b658753a603301512896ed22cb7434881c6800dad2593c39f457238fdcf252a98d2dc18a16d0d541fb9e8660a581e08
-  data.tar.gz: 9de4cd5667d7dfc9a7eb890e067d3d3dc756f5f31a4a2b35ef9e49aa9790dcb31f1efd8ad7b6c421a0fd76aaf2e2de8aa38c50f4da8418efb059c30fec3f5d27
+  metadata.gz: 6282c28251d01ed1f7c196fbb421c3e895d37681da8e71e5941ed74db3ff88aff39e8e9c8604fe899d555e61aec5bc7b8824fcdf30e6e789c3b74086d25ae7ee
+  data.tar.gz: bf00a26818a96154c91a2a1f281d219372f0fd97b8b0075ddbb70fcebaa675c28b31e55a10bf218303fcc4e2b0ad15229a30950e2f2a5e41cd174995940c0a2a

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.1.1] - 2025-04-18
+
+### Fixed
+- Fixed URL-based file attachments by ensuring they use proper multipart form encoding
+
+## [1.1.0] - 2025-04-17
+
+### Added
+- Support for URL-based file attachments
+- Enhanced attachment handling for various file types
+- Added MIME type detection for file uploads
+
 ## [1.0.0] - 2024-03-21
 
 ### Changed

data/lib/pylon/client.rb

@@ -6,7 +6,23 @@ module Pylon
   # @example
   #   client = Pylon::Client.new(api_key: 'your_api_key')
   #   issues = client.list_issues(start_time: '2024-03-01T00:00:00Z', end_time: '2024-03-31T23:59:59Z')
+  #   issues.each { |issue| puts issue.title }
+  # rubocop:disable Metrics/ClassLength
   class Client
+    # Common MIME types for file uploads
+    MIME_TYPES = {
+      ".jpg" => "image/jpeg",
+      ".jpeg" => "image/jpeg",
+      ".png" => "image/png",
+      ".gif" => "image/gif",
+      ".pdf" => "application/pdf",
+      ".doc" => "application/msword",
+      ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".xls" => "application/vnd.ms-excel",
+      ".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".csv" => "text/csv",
+      ".txt" => "text/plain"
+    }
     # Base URL for the Pylon API
     BASE_URL = "https://api.usepylon.com"
 
@@ -28,76 +44,104 @@ module Pylon
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of accounts
+    # @return [Models::Collection<Models::Account>] Collection of account objects
     def list_accounts(page: 1, per_page: 20)
-      get("/accounts", query: { page: page, per_page: per_page })
+      get("/accounts", query: { page: page, per_page: per_page }, 
+          model_class: Models::Account, collection: true)
     end
 
     # Get details for a specific account
     #
     # @param account_id [String] The ID of the account to retrieve
-    # @return [Hash] Account details
+    # @return [Models::Account] Account object
     def get_account(account_id)
-      get("/accounts/#{account_id}")
+      get("/accounts/#{account_id}", model_class: Models::Account)
     end
 
     # Create a new attachment
     #
-    # @param file [String] The file content to upload
-    # @return [Hash] Created attachment details
-    def create_attachment(file)
-      post("/attachments", body: { file: file })
+    # @param file [File, String, nil] The file to upload (File object or file content)
+    # @param description [String, nil] A text description of the file
+    # @param file_url [String, nil] A URL to fetch the file from if file is not provided
+    # @return [Models::Attachment] Created attachment object
+    # @raise [ArgumentError] If neither file nor file_url is provided
+    def create_attachment(file = nil, description: nil, file_url: nil)
+      if file.nil? && file_url.nil?
+        raise ArgumentError, "Either file or file_url must be provided"
+      end
+
+      params = {}
+      params[:description] = description if description
+      params[:file_url] = file_url if file_url
+
+      if file
+        if file.is_a?(::File) || (file.respond_to?(:path) && file.respond_to?(:read))
+          # For File objects or IO-like objects
+          params[:file] = Faraday::UploadIO.new(file, mime_type_for_file(file), File.basename(file.path))
+        else
+          # For raw content as string, create a temp file
+          temp_file = Tempfile.new(["upload", ".bin"])
+          temp_file.binmode
+          temp_file.write(file)
+          temp_file.rewind
+          params[:file] = Faraday::UploadIO.new(temp_file, "application/octet-stream")
+        end
+      end
+      
+      # Always use multipart for attachments, whether file or file_url
+      post_multipart("/attachments", params, model_class: Models::Attachment)
     end
 
     # Get details for a specific attachment
     #
     # @param attachment_id [String] The ID of the attachment to retrieve
-    # @return [Hash] Attachment details
+    # @return [Models::Attachment] Attachment object
     def get_attachment(attachment_id)
-      get("/attachments/#{attachment_id}")
+      get("/attachments/#{attachment_id}", model_class: Models::Attachment)
     end
 
     # List all contacts with pagination
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of contacts
+    # @return [Models::Collection<Models::Contact>] Collection of contact objects
     def list_contacts(page: 1, per_page: 20)
-      get("/contacts", query: { page: page, per_page: per_page })
+      get("/contacts", query: { page: page, per_page: per_page }, 
+          model_class: Models::Contact, collection: true)
     end
 
     # Create a new contact
     #
     # @param params [Hash] Contact parameters
-    # @return [Hash] Created contact details
+    # @return [Models::Contact] Created contact object
     def create_contact(params)
-      post("/contacts", body: params)
+      post("/contacts", body: params, model_class: Models::Contact)
     end
 
     # Get details for a specific contact
     #
     # @param contact_id [String] The ID of the contact to retrieve
-    # @return [Hash] Contact details
+    # @return [Models::Contact] Contact object
     def get_contact(contact_id)
-      get("/contacts/#{contact_id}")
+      get("/contacts/#{contact_id}", model_class: Models::Contact)
     end
 
     # Update an existing contact
     #
     # @param contact_id [String] The ID of the contact to update
     # @param params [Hash] Updated contact parameters
-    # @return [Hash] Updated contact details
+    # @return [Models::Contact] Updated contact object
     def update_contact(contact_id, params)
-      patch("/contacts/#{contact_id}", body: params)
+      patch("/contacts/#{contact_id}", body: params, model_class: Models::Contact)
     end
 
     # List all custom fields with pagination
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of custom fields
+    # @return [Models::Collection] Collection of custom fields
     def list_custom_fields(page: 1, per_page: 20)
-      get("/custom_fields", query: { page: page, per_page: per_page })
+      get("/custom_fields", query: { page: page, per_page: per_page }, collection: true)
     end
 
     # Create a new custom field
@@ -115,7 +159,7 @@ module Pylon
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
     # @param filters [Hash] Additional filters to apply
-    # @return [Array<Hash>] List of issues
+    # @return [Models::Collection<Models::Issue>] Collection of issue objects
     # @raise [ArgumentError] If start_time or end_time is missing
     def list_issues(start_time:, end_time:, page: 1, per_page: 20, **filters)
       raise ArgumentError, "start_time is required" unless start_time
@@ -126,135 +170,140 @@ module Pylon
         end_time: end_time,
         page: page,
         per_page: per_page
-      ))
+      ), model_class: Models::Issue, collection: true)
     end
 
     # Create a new issue
     #
     # @param params [Hash] Issue parameters
-    # @return [Hash] Created issue details
+    # @return [Models::Issue] Created issue object
     def create_issue(params)
-      post("/issues", body: params)
+      post("/issues", body: params, model_class: Models::Issue)
     end
 
     # Get details for a specific issue
     #
     # @param issue_id [String] The ID of the issue to retrieve
-    # @return [Hash] Issue details
+    # @return [Models::Issue] Issue object
     def get_issue(issue_id)
-      get("/issues/#{issue_id}")
+      get("/issues/#{issue_id}", model_class: Models::Issue)
     end
 
     # Update an existing issue
     #
     # @param issue_id [String] The ID of the issue to update
     # @param params [Hash] Updated issue parameters
-    # @return [Hash] Updated issue details
+    # @return [Models::Issue] Updated issue object
     def update_issue(issue_id, params)
-      patch("/issues/#{issue_id}", body: params)
+      patch("/issues/#{issue_id}", body: params, model_class: Models::Issue)
     end
 
     # Snooze an issue until a specified time
     #
     # @param issue_id [String] The ID or number of the issue to snooze
     # @param snooze_until [String] The date and time to snooze the issue until (RFC3339 format)
-    # @return [Hash] Updated issue details
+    # @return [Models::Issue] Updated issue object
     def snooze_issue(issue_id, snooze_until:)
-      post("/issues/#{issue_id}/snooze", body: { snooze_until: snooze_until })
+      post("/issues/#{issue_id}/snooze", body: { snooze_until: snooze_until }, 
+          model_class: Models::Issue)
     end
 
     # List all knowledge base articles with pagination
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of articles
+    # @return [Models::Collection<Models::Article>] Collection of article objects
     def list_articles(page: 1, per_page: 20)
-      get("/knowledge_base/articles", query: { page: page, per_page: per_page })
+      get("/knowledge_base/articles", query: { page: page, per_page: per_page }, 
+          model_class: Models::Article, collection: true)
     end
 
     # Get details for a specific article
     #
     # @param article_id [String] The ID of the article to retrieve
-    # @return [Hash] Article details
+    # @return [Models::Article] Article object
     def get_article(article_id)
-      get("/knowledge_base/articles/#{article_id}")
+      get("/knowledge_base/articles/#{article_id}", model_class: Models::Article)
     end
 
     # Get details for the current user
     #
-    # @return [Hash] Current user details
+    # @return [Models::User] Current user object
     def get_current_user
-      get("/me")
+      get("/me", model_class: Models::User)
     end
 
     # List all tags with pagination
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of tags
+    # @return [Models::Collection<Models::Tag>] Collection of tag objects
     def list_tags(page: 1, per_page: 20)
-      get("/tags", query: { page: page, per_page: per_page })
+      get("/tags", query: { page: page, per_page: per_page }, 
+          model_class: Models::Tag, collection: true)
     end
 
     # Create a new tag
     #
     # @param name [String] The name of the tag
     # @param color [String] Optional hex color code for the tag
-    # @return [Hash] Created tag details
+    # @return [Models::Tag] Created tag object
     def create_tag(name:, color: nil)
-      post("/tags", body: { name: name, color: color }.compact)
+      post("/tags", body: { name: name, color: color }.compact, model_class: Models::Tag)
     end
 
     # List all teams with pagination
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of teams
+    # @return [Models::Collection<Models::Team>] Collection of team objects
     def list_teams(page: 1, per_page: 20)
-      get("/teams", query: { page: page, per_page: per_page })
+      get("/teams", query: { page: page, per_page: per_page }, 
+          model_class: Models::Team, collection: true)
     end
 
     # Create a new team
     #
     # @param params [Hash] Team parameters
-    # @return [Hash] Created team details
+    # @return [Models::Team] Created team object
     def create_team(params)
-      post("/teams", body: params)
+      post("/teams", body: params, model_class: Models::Team)
     end
 
     # Get details for a specific team
     #
     # @param team_id [String] The ID of the team to retrieve
-    # @return [Hash] Team details
+    # @return [Models::Team] Team object
     def get_team(team_id)
-      get("/teams/#{team_id}")
+      get("/teams/#{team_id}", model_class: Models::Team)
     end
 
     # List all ticket forms with pagination
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of ticket forms
+    # @return [Models::Collection<Models::TicketForm>] Collection of ticket form objects
     def list_ticket_forms(page: 1, per_page: 20)
-      get("/ticket-forms", query: { page: page, per_page: per_page })
+      get("/ticket-forms", query: { page: page, per_page: per_page }, 
+          model_class: Models::TicketForm, collection: true)
     end
 
     # Create a new ticket form
     #
     # @param name [String] The name of the form
     # @param fields [Array<Hash>] Array of form field definitions
-    # @return [Hash] Created ticket form details
+    # @return [Models::TicketForm] Created ticket form object
     def create_ticket_form(name:, fields: [])
-      post("/ticket-forms", body: { name: name, fields: fields })
+      post("/ticket-forms", body: { name: name, fields: fields }, model_class: Models::TicketForm)
     end
 
     # List all user roles with pagination
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of user roles
+    # @return [Models::Collection] Collection of user role objects
     def list_user_roles(page: 1, per_page: 20)
-      get("/user_roles", query: { page: page, per_page: per_page })
+      get("/user_roles", query: { page: page, per_page: per_page }, collection: true)
     end
 
     # Get details for a specific user role
@@ -269,34 +318,35 @@ module Pylon
     #
     # @param page [Integer] Page number for pagination
     # @param per_page [Integer] Number of items per page
-    # @return [Array<Hash>] List of users
+    # @return [Models::Collection<Models::User>] Collection of user objects
     def list_users(page: 1, per_page: 20)
-      get("/users", query: { page: page, per_page: per_page })
+      get("/users", query: { page: page, per_page: per_page }, 
+          model_class: Models::User, collection: true)
     end
 
     # Create a new user
     #
     # @param params [Hash] User parameters
-    # @return [Hash] Created user details
+    # @return [Models::User] Created user object
     def create_user(params)
-      post("/users", body: params)
+      post("/users", body: params, model_class: Models::User)
     end
 
     # Get details for a specific user
     #
     # @param user_id [String] The ID of the user to retrieve
-    # @return [Hash] User details
+    # @return [Models::User] User object
     def get_user(user_id)
-      get("/users/#{user_id}")
+      get("/users/#{user_id}", model_class: Models::User)
     end
 
     # Update an existing user
     #
     # @param user_id [String] The ID of the user to update
     # @param params [Hash] Updated user parameters
-    # @return [Hash] Updated user details
+    # @return [Models::User] Updated user object
     def update_user(user_id, params)
-      patch("/users/#{user_id}", body: params)
+      patch("/users/#{user_id}", body: params, model_class: Models::User)
     end
 
     private
@@ -315,26 +365,71 @@ module Pylon
       end
     end
 
+    # Determine MIME type for file
+    #
+    # @param file [File] The file to determine MIME type for
+    # @return [String] The MIME type
+    def mime_type_for_file(file)
+      return "application/octet-stream" unless file.respond_to?(:path)
+
+      ext = File.extname(file.path).downcase
+      MIME_TYPES[ext] || "application/octet-stream"
+    end
+
     # Handle API response and raise appropriate errors
     #
     # @param response [Faraday::Response] The API response
-    # @return [Array] Array containing response data and response object
+    # @param model_class [Class] The model class to use for wrapping the response
+    # @param collection [Boolean] Whether the response is a collection of items
+    # @return [Models::Base, Models::Collection, Array] Model, Collection, or response data array
     # @raise [AuthenticationError] If authentication fails
     # @raise [ResourceNotFoundError] If resource is not found
     # @raise [ValidationError] If request parameters are invalid
     # @raise [ApiError] For other API errors
-    def handle_response(response)
+    def handle_response(response, model_class = nil, collection = false)
       if @debug
         puts "Request URL: #{response.env.url}"
         puts "Response status: #{response.status}"
         puts "Response body: #{response.body.inspect}"
       end
 
-      case response.status
-      when 200..299
-        data = response.body
-        data = data["data"] if data.is_a?(Hash) && data.key?("data")
+      if response.status.between?(200, 299)
+        return handle_successful_response(response, model_class, collection)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Handle successful API response
+    #
+    # @param response [Faraday::Response] The API response
+    # @param model_class [Class] The model class to use for wrapping the response
+    # @param collection [Boolean] Whether the response is a collection of items
+    # @return [Models::Base, Models::Collection, Array] Wrapped response data
+    def handle_successful_response(response, model_class, collection)
+      data = response.body
+      data = data["data"] if data.is_a?(Hash) && data.key?("data")
+      
+      if model_class
+        if collection
+          Models::Collection.new(data, model_class, response)
+        else
+          model_class.new(data, response)
+        end
+      else
         [data, response]
+      end
+    end
+
+    # Handle error API response
+    #
+    # @param response [Faraday::Response] The API response
+    # @raise [AuthenticationError] If authentication fails
+    # @raise [ResourceNotFoundError] If resource is not found
+    # @raise [ValidationError] If request parameters are invalid
+    # @raise [ApiError] For other API errors
+    def handle_error_response(response)
+      case response.status
       when 401
         raise AuthenticationError, parse_error_message(response) || "Invalid API key"
       when 404
@@ -366,35 +461,71 @@ module Pylon
     #
     # @param path [String] The API endpoint path
     # @param query [Hash] Query parameters
-    # @return [Array] Array containing response data and response object
-    def get(path, query: {})
-      handle_response(connection.get(path, query))
+    # @param model_class [Class] The model class to use for wrapping the response
+    # @param collection [Boolean] Whether the response is a collection of items
+    # @return [Models::Base, Models::Collection, Array] Model, Collection, or response data array
+    def get(path, query: {}, model_class: nil, collection: false)
+      handle_response(connection.get(path, query), model_class, collection)
     end
 
     # Make a POST request
     #
     # @param path [String] The API endpoint path
     # @param body [Hash] Request body
-    # @return [Array] Array containing response data and response object
-    def post(path, body: {})
-      handle_response(connection.post(path, body.to_json))
+    # @param model_class [Class] The model class to use for wrapping the response
+    # @param collection [Boolean] Whether the response is a collection of items
+    # @return [Models::Base, Models::Collection, Array] Model, Collection, or response data array
+    def post(path, body: {}, model_class: nil, collection: false)
+      handle_response(connection.post(path, body.to_json), model_class, collection)
+    end
+
+    # Make a multipart POST request for file uploads
+    #
+    # @param path [String] The API endpoint path
+    # @param params [Hash] Request parameters including file uploads
+    # @param model_class [Class] The model class to use for wrapping the response
+    # @param collection [Boolean] Whether the response is a collection of items
+    # @return [Models::Base, Models::Collection, Array] Model, Collection, or response data array
+    def post_multipart(path, params = {}, model_class: nil, collection: false)
+      # Create a connection without the default JSON content type for multipart uploads
+      multipart_conn = Faraday.new(@base_url) do |f|
+        f.request :multipart
+        # Only force multipart for file_url uploads, omit url_encoded middleware
+        f.response :json, content_type: /\bjson$/
+        f.response :logger if @debug
+        f.adapter Faraday.default_adapter
+        f.headers["Authorization"] = "Bearer #{api_key}"
+        f.headers["Accept"] = "application/json"
+      end
+      
+      # If we have a file_url but no actual file, create a dummy file part to force multipart encoding
+      if params[:file_url] && !params[:file]
+        # Create an empty file part to force multipart encoding
+        params[:_dummy] = Faraday::FilePart.new(StringIO.new(""), "application/octet-stream", "dummy")
+      end
+
+      handle_response(multipart_conn.post(path, params), model_class, collection)
     end
 
     # Make a PATCH request
     #
     # @param path [String] The API endpoint path
     # @param body [Hash] Request body
-    # @return [Array] Array containing response data and response object
-    def patch(path, body: {})
-      handle_response(connection.patch(path, body.to_json))
+    # @param model_class [Class] The model class to use for wrapping the response
+    # @param collection [Boolean] Whether the response is a collection of items
+    # @return [Models::Base, Models::Collection, Array] Model, Collection, or response data array
+    def patch(path, body: {}, model_class: nil, collection: false)
+      handle_response(connection.patch(path, body.to_json), model_class, collection)
     end
 
     # Make a DELETE request
     #
     # @param path [String] The API endpoint path
-    # @return [Array] Array containing response data and response object
-    def delete(path)
-      handle_response(connection.delete(path))
+    # @param model_class [Class] The model class to use for wrapping the response
+    # @param collection [Boolean] Whether the response is a collection of items
+    # @return [Models::Base, Models::Collection, Array] Model, Collection, or response data array
+    def delete(path, model_class: nil, collection: false)
+      handle_response(connection.delete(path), model_class, collection)
     end
   end
-end
+end

data/lib/pylon/models/account.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Account < Base
+    end
+  end
+end

data/lib/pylon/models/article.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Article < Base
+    end
+  end
+end

data/lib/pylon/models/attachment.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Attachment < Base
+    end
+  end
+end

data/lib/pylon/models/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Base
+      attr_reader :attributes, :_response
+
+      def initialize(attributes = {}, response = nil)
+        @attributes = attributes || {}
+        @_response = response
+      end
+
+      def method_missing(method_name, *args, &block)
+        key = method_name.to_s
+        if @attributes.key?(key)
+          @attributes[key]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @attributes.key?(method_name.to_s) || super
+      end
+
+      def [](key)
+        @attributes[key.to_s]
+      end
+
+      def to_h
+        @attributes
+      end
+      alias to_hash to_h
+
+      def inspect
+        "#<#{self.class.name} #{@attributes.inspect}>"
+      end
+    end
+  end
+end

data/lib/pylon/models/collection.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Collection
+      include Enumerable
+      
+      attr_reader :items, :_response
+      
+      def initialize(items = [], model_class = nil, response = nil)
+        @items = items.map do |item|
+          model_class ? model_class.new(item) : item
+        end
+        @_response = response
+      end
+      
+      def each(&block)
+        @items.each(&block)
+      end
+      
+      def [](index)
+        @items[index]
+      end
+      
+      def size
+        @items.size
+      end
+      alias length size
+      
+      def to_a
+        @items
+      end
+      
+      def inspect
+        "#<#{self.class.name} items=#{@items.size}>"
+      end
+    end
+  end
+end

data/lib/pylon/models/contact.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Contact < Base
+    end
+  end
+end

data/lib/pylon/models/issue.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Issue < Base
+    end
+  end
+end

data/lib/pylon/models/tag.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Tag < Base
+    end
+  end
+end

data/lib/pylon/models/team.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class Team < Base
+    end
+  end
+end

data/lib/pylon/models/ticket_form.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class TicketForm < Base
+    end
+  end
+end

data/lib/pylon/models/user.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pylon
+  module Models
+    class User < Base
+    end
+  end
+end

data/lib/pylon/version.rb

@@ -4,9 +4,9 @@ module Pylon
   # Major version for breaking changes
   MAJOR = 1
   # Minor version for new features
-  MINOR = 0
+  MINOR = 1
   # Patch version for bug fixes
-  PATCH = 0
+  PATCH = 1
   # Pre-release version (optional)
   PRE = nil
 

data/lib/pylon.rb

@@ -3,8 +3,20 @@
 require "faraday"
 require "faraday/multipart"
 require "json"
+require "tempfile"
 
 require_relative "pylon/version"
+require_relative "pylon/models/base"
+require_relative "pylon/models/collection"
+require_relative "pylon/models/user"
+require_relative "pylon/models/account"
+require_relative "pylon/models/issue"
+require_relative "pylon/models/team"
+require_relative "pylon/models/tag"
+require_relative "pylon/models/attachment"
+require_relative "pylon/models/contact"
+require_relative "pylon/models/ticket_form"
+require_relative "pylon/models/article"
 require_relative "pylon/client"
 
 module Pylon

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pylon-api
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Ben Odom
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-15 00:00:00.000000000 Z
+date: 2025-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -134,6 +134,17 @@ files:
 - README.md
 - lib/pylon.rb
 - lib/pylon/client.rb
+- lib/pylon/models/account.rb
+- lib/pylon/models/article.rb
+- lib/pylon/models/attachment.rb
+- lib/pylon/models/base.rb
+- lib/pylon/models/collection.rb
+- lib/pylon/models/contact.rb
+- lib/pylon/models/issue.rb
+- lib/pylon/models/tag.rb
+- lib/pylon/models/team.rb
+- lib/pylon/models/ticket_form.rb
+- lib/pylon/models/user.rb
 - lib/pylon/version.rb
 - lib/tasks/version.rake
 homepage: https://github.com/benjodo/pylon-api