autorender 0.1.0

data/rbi/autorender/models/upload_create_response.rbi

@@ -0,0 +1,174 @@
+# typed: strong
+
+module Autorender
+  module Models
+    class UploadCreateResponse < Autorender::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Autorender::Models::UploadCreateResponse,
+            Autorender::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :custom_id
+
+      sig { returns(String) }
+      attr_accessor :extension
+
+      sig { returns(String) }
+      attr_accessor :file_no
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :folder_no
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :height
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_duplicate
+
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :metadata
+
+      sig { returns(String) }
+      attr_accessor :mime_type
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(String) }
+      attr_accessor :path
+
+      sig { returns(Integer) }
+      attr_accessor :size
+
+      sig { returns(T::Array[String]) }
+      attr_accessor :tags
+
+      sig { returns(String) }
+      attr_accessor :thumbnail
+
+      sig { returns(String) }
+      attr_accessor :upload_source
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :width
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :format_
+
+      sig { params(format_: String).void }
+      attr_writer :format_
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :hash_
+
+      sig { params(hash_: String).void }
+      attr_writer :hash_
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_private
+
+      sig { params(is_private: T::Boolean).void }
+      attr_writer :is_private
+
+      # Upload created
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          custom_id: T.nilable(String),
+          extension: String,
+          file_no: String,
+          folder_no: T.nilable(String),
+          height: T.nilable(Integer),
+          is_duplicate: T::Boolean,
+          metadata: T.nilable(T::Hash[Symbol, T.anything]),
+          mime_type: String,
+          name: String,
+          path: String,
+          size: Integer,
+          tags: T::Array[String],
+          thumbnail: String,
+          upload_source: String,
+          url: String,
+          width: T.nilable(Integer),
+          workspace_id: String,
+          format_: String,
+          hash_: String,
+          is_private: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        created_at:,
+        custom_id:,
+        extension:,
+        file_no:,
+        folder_no:,
+        height:,
+        is_duplicate:,
+        metadata:,
+        mime_type:,
+        name:,
+        path:,
+        size:,
+        tags:,
+        thumbnail:,
+        upload_source:,
+        url:,
+        width:,
+        workspace_id:,
+        format_: nil,
+        hash_: nil,
+        is_private: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            custom_id: T.nilable(String),
+            extension: String,
+            file_no: String,
+            folder_no: T.nilable(String),
+            height: T.nilable(Integer),
+            is_duplicate: T::Boolean,
+            metadata: T.nilable(T::Hash[Symbol, T.anything]),
+            mime_type: String,
+            name: String,
+            path: String,
+            size: Integer,
+            tags: T::Array[String],
+            thumbnail: String,
+            upload_source: String,
+            url: String,
+            width: T.nilable(Integer),
+            workspace_id: String,
+            format_: String,
+            hash_: String,
+            is_private: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/autorender/models.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Autorender
+  FileDeleteParams = Autorender::Models::FileDeleteParams
+
+  FileListParams = Autorender::Models::FileListParams
+
+  FileRenameParams = Autorender::Models::FileRenameParams
+
+  FileRetrieveParams = Autorender::Models::FileRetrieveParams
+
+  FolderCreateParams = Autorender::Models::FolderCreateParams
+
+  FolderDeleteParams = Autorender::Models::FolderDeleteParams
+
+  FolderListParams = Autorender::Models::FolderListParams
+
+  FolderRenameParams = Autorender::Models::FolderRenameParams
+
+  MultipartUploadCompleteParams =
+    Autorender::Models::MultipartUploadCompleteParams
+
+  MultipartUploadStartParams = Autorender::Models::MultipartUploadStartParams
+
+  UploadCreateFromURLParams = Autorender::Models::UploadCreateFromURLParams
+
+  UploadCreateParams = Autorender::Models::UploadCreateParams
+end

data/rbi/autorender/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Autorender
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Autorender::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Autorender::RequestOptions, Autorender::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Autorender::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Autorender::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/autorender/resources/files.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Autorender
+  module Resources
+    # File management endpoints (API key required)
+    class Files
+      # Get file details
+      sig do
+        params(
+          file_no: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::FileRetrieveResponse)
+      end
+      def retrieve(file_no, request_options: {})
+      end
+
+      # List/search files with pagination, filtering, and sorting.
+      sig do
+        params(
+          folder_no: String,
+          limit: Integer,
+          page: Integer,
+          search: String,
+          sort: Autorender::FileListParams::Sort::OrSymbol,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::FileListResponse)
+      end
+      def list(
+        # Filter by folder number
+        folder_no: nil,
+        limit: nil,
+        page: nil,
+        # Partial name match (case-insensitive)
+        search: nil,
+        sort: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete file
+      sig do
+        params(
+          file_no: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).void
+      end
+      def delete(file_no, request_options: {})
+      end
+
+      # Rename file
+      sig do
+        params(
+          file_no: String,
+          name: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::FileRenameResponse)
+      end
+      def rename(
+        file_no,
+        # New file name without extension or path separators
+        name:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Autorender::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/autorender/resources/folders.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Autorender
+  module Resources
+    # Folder management endpoints (API key required)
+    class Folders
+      # Create folder
+      sig do
+        params(
+          name: String,
+          parent_folder_no: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::FolderCreateResponse)
+      end
+      def create(
+        # Folder name without slashes
+        name:,
+        # Parent folder number
+        parent_folder_no: nil,
+        request_options: {}
+      )
+      end
+
+      # List folders
+      sig do
+        params(
+          parent_folder_no: String,
+          search: String,
+          sort: Autorender::FolderListParams::Sort::OrSymbol,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::FolderListResponse)
+      end
+      def list(
+        # Filter by parent folder number
+        parent_folder_no: nil,
+        # Partial name match (case-insensitive)
+        search: nil,
+        sort: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete folder
+      sig do
+        params(
+          folder_no: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).void
+      end
+      def delete(folder_no, request_options: {})
+      end
+
+      # Rename folder
+      sig do
+        params(
+          folder_no: String,
+          name: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::FolderRenameResponse)
+      end
+      def rename(
+        folder_no,
+        # New folder name without slashes
+        name:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Autorender::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/autorender/resources/multipart_uploads.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Autorender
+  module Resources
+    # Upload endpoints (API key required)
+    class MultipartUploads
+      # Finalise a multipart upload session and return the stored file record.
+      sig do
+        params(
+          session_id: String,
+          uuid: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::MultipartUploadCompleteResponse)
+      end
+      def complete(session_id:, uuid: nil, request_options: {})
+      end
+
+      # Initialise a multipart upload session and receive pre-signed part URLs.
+      sig do
+        params(
+          file_name: String,
+          format_: String,
+          size: Integer,
+          custom_id: String,
+          folder: String,
+          metadata: T::Hash[Symbol, T.anything],
+          random_prefix: T::Boolean,
+          tags: Autorender::MultipartUploadStartParams::Tags::Variants,
+          ttl_seconds: Integer,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::MultipartUploadStartResponse)
+      end
+      def start(
+        file_name:,
+        format_:,
+        size:,
+        custom_id: nil,
+        folder: nil,
+        metadata: nil,
+        random_prefix: nil,
+        tags: nil,
+        ttl_seconds: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Autorender::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/autorender/resources/uploads.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Autorender
+  module Resources
+    # Upload endpoints (API key required)
+    class Uploads
+      # Upload a file from your backend server using multipart/form-data.
+      sig do
+        params(
+          file: Autorender::Internal::FileInput,
+          file_name: String,
+          custom_id: String,
+          folder: String,
+          metadata: String,
+          random_prefix: String,
+          tags: String,
+          transform: String,
+          webhook_url: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::UploadCreateResponse)
+      end
+      def create(
+        # File to upload.
+        file:,
+        # File name (e.g. product.jpg)
+        file_name:,
+        # Custom identifier
+        custom_id: nil,
+        # Optional folder path
+        folder: nil,
+        # JSON string of metadata
+        metadata: nil,
+        # true/false to append random suffix
+        random_prefix: nil,
+        # Comma-separated tags
+        tags: nil,
+        # Transform string (w_300,h_300,c_crop,...)
+        transform: nil,
+        # URL to notify on success
+        webhook_url: nil,
+        request_options: {}
+      )
+      end
+
+      # Download a file from a remote URL and store it in AutoRender.
+      sig do
+        params(
+          remote_url: String,
+          custom_id: String,
+          file_name: String,
+          folder: String,
+          metadata: String,
+          random_prefix: String,
+          tags: String,
+          webhook_url: String,
+          request_options: Autorender::RequestOptions::OrHash
+        ).returns(Autorender::Models::UploadCreateFromURLResponse)
+      end
+      def create_from_url(
+        # HTTP/HTTPS URL to fetch
+        remote_url:,
+        custom_id: nil,
+        # Override file name
+        file_name: nil,
+        # Destination folder path
+        folder: nil,
+        # JSON string of metadata object
+        metadata: nil,
+        # true/false to append random suffix
+        random_prefix: nil,
+        # Comma-separated tags
+        tags: nil,
+        webhook_url: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Autorender::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/autorender/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module Autorender
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sig/autorender/client.rbs

@@ -0,0 +1,32 @@
+module Autorender
+  class Client < Autorender::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    attr_reader api_key: String?
+
+    attr_reader uploads: Autorender::Resources::Uploads
+
+    attr_reader files: Autorender::Resources::Files
+
+    attr_reader folders: Autorender::Resources::Folders
+
+    attr_reader multipart_uploads: Autorender::Resources::MultipartUploads
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    def initialize: (
+      ?api_key: String?,
+      ?base_url: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end

data/sig/autorender/errors.rbs

@@ -0,0 +1,117 @@
+module Autorender
+  module Errors
+    class Error < StandardError
+      attr_accessor cause: StandardError?
+    end
+
+    class ConversionError < Autorender::Errors::Error
+      def cause: -> StandardError?
+
+      def initialize: (
+        on: Class,
+        method: Symbol,
+        target: top,
+        value: top,
+        ?cause: StandardError?
+      ) -> void
+    end
+
+    class APIError < Autorender::Errors::Error
+      attr_accessor url: URI::Generic
+
+      attr_accessor status: Integer?
+
+      attr_accessor headers: ::Hash[String, String]?
+
+      attr_accessor body: top?
+
+      def initialize: (
+        url: URI::Generic,
+        ?status: Integer?,
+        ?headers: ::Hash[String, String]?,
+        ?body: Object?,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIConnectionError < Autorender::Errors::APIError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APITimeoutError < Autorender::Errors::APIConnectionError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIStatusError < Autorender::Errors::APIError
+      def self.for: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> instance
+
+      def initialize: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class BadRequestError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: 400
+    end
+
+    class AuthenticationError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: 401
+    end
+
+    class PermissionDeniedError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: 403
+    end
+
+    class NotFoundError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: 404
+    end
+
+    class ConflictError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: 409
+    end
+
+    class UnprocessableEntityError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: 422
+    end
+
+    class RateLimitError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: 429
+    end
+
+    class InternalServerError < Autorender::Errors::APIStatusError
+      HTTP_STATUS: Range[Integer]
+    end
+  end
+end