autorender 0.1.0

data/rbi/autorender/models/multipart_upload_start_params.rbi

@@ -0,0 +1,138 @@
+# typed: strong
+
+module Autorender
+  module Models
+    class MultipartUploadStartParams < Autorender::Internal::Type::BaseModel
+      extend Autorender::Internal::Type::RequestParameters::Converter
+      include Autorender::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Autorender::MultipartUploadStartParams,
+            Autorender::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :file_name
+
+      sig { returns(String) }
+      attr_accessor :format_
+
+      sig { returns(Integer) }
+      attr_accessor :size
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :custom_id
+
+      sig { params(custom_id: String).void }
+      attr_writer :custom_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :folder
+
+      sig { params(folder: String).void }
+      attr_writer :folder
+
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :metadata
+
+      sig { params(metadata: T::Hash[Symbol, T.anything]).void }
+      attr_writer :metadata
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :random_prefix
+
+      sig { params(random_prefix: T::Boolean).void }
+      attr_writer :random_prefix
+
+      sig do
+        returns(
+          T.nilable(Autorender::MultipartUploadStartParams::Tags::Variants)
+        )
+      end
+      attr_reader :tags
+
+      sig do
+        params(
+          tags: Autorender::MultipartUploadStartParams::Tags::Variants
+        ).void
+      end
+      attr_writer :tags
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :ttl_seconds
+
+      sig { params(ttl_seconds: Integer).void }
+      attr_writer :ttl_seconds
+
+      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(T.attached_class)
+      end
+      def self.new(
+        file_name:,
+        format_:,
+        size:,
+        custom_id: nil,
+        folder: nil,
+        metadata: nil,
+        random_prefix: nil,
+        tags: nil,
+        ttl_seconds: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            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
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Tags
+        extend Autorender::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(T::Array[String], String) }
+
+        sig do
+          override.returns(
+            T::Array[Autorender::MultipartUploadStartParams::Tags::Variants]
+          )
+        end
+        def self.variants
+        end
+
+        StringArray =
+          T.let(
+            Autorender::Internal::Type::ArrayOf[String],
+            Autorender::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/autorender/models/multipart_upload_start_response.rbi

@@ -0,0 +1,146 @@
+# typed: strong
+
+module Autorender
+  module Models
+    class MultipartUploadStartResponse < Autorender::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Autorender::Models::MultipartUploadStartResponse,
+            Autorender::Internal::AnyHash
+          )
+        end
+
+      # Unix timestamp when the session expires
+      sig { returns(Integer) }
+      attr_accessor :expire_at
+
+      sig { returns(Integer) }
+      attr_accessor :min_part_size
+
+      sig { returns(Integer) }
+      attr_accessor :part_size
+
+      # Pre-signed S3 upload URLs, one per part
+      sig { returns(T::Array[String]) }
+      attr_accessor :parts
+
+      sig { returns(Autorender::Models::MultipartUploadStartResponse::Policy) }
+      attr_reader :policy
+
+      sig do
+        params(
+          policy:
+            Autorender::Models::MultipartUploadStartResponse::Policy::OrHash
+        ).void
+      end
+      attr_writer :policy
+
+      sig { returns(String) }
+      attr_accessor :public_key
+
+      sig { returns(String) }
+      attr_accessor :session_id
+
+      sig { returns(String) }
+      attr_accessor :uuid
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # Session created
+      sig do
+        params(
+          expire_at: Integer,
+          min_part_size: Integer,
+          part_size: Integer,
+          parts: T::Array[String],
+          policy:
+            Autorender::Models::MultipartUploadStartResponse::Policy::OrHash,
+          public_key: String,
+          session_id: String,
+          uuid: String,
+          workspace_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unix timestamp when the session expires
+        expire_at:,
+        min_part_size:,
+        part_size:,
+        # Pre-signed S3 upload URLs, one per part
+        parts:,
+        policy:,
+        public_key:,
+        session_id:,
+        uuid:,
+        workspace_id:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            expire_at: Integer,
+            min_part_size: Integer,
+            part_size: Integer,
+            parts: T::Array[String],
+            policy: Autorender::Models::MultipartUploadStartResponse::Policy,
+            public_key: String,
+            session_id: String,
+            uuid: String,
+            workspace_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Policy < Autorender::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Autorender::Models::MultipartUploadStartResponse::Policy,
+              Autorender::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :folder
+
+        sig { returns(String) }
+        attr_accessor :format_
+
+        sig { returns(Integer) }
+        attr_accessor :size
+
+        sig { returns(T::Array[String]) }
+        attr_accessor :tags
+
+        sig do
+          params(
+            folder: String,
+            format_: String,
+            size: Integer,
+            tags: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(folder:, format_:, size:, tags:)
+        end
+
+        sig do
+          override.returns(
+            {
+              folder: String,
+              format_: String,
+              size: Integer,
+              tags: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/autorender/models/upload_create_from_url_params.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module Autorender
+  module Models
+    class UploadCreateFromURLParams < Autorender::Internal::Type::BaseModel
+      extend Autorender::Internal::Type::RequestParameters::Converter
+      include Autorender::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Autorender::UploadCreateFromURLParams,
+            Autorender::Internal::AnyHash
+          )
+        end
+
+      # HTTP/HTTPS URL to fetch
+      sig { returns(String) }
+      attr_accessor :remote_url
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :custom_id
+
+      sig { params(custom_id: String).void }
+      attr_writer :custom_id
+
+      # Override file name
+      sig { returns(T.nilable(String)) }
+      attr_reader :file_name
+
+      sig { params(file_name: String).void }
+      attr_writer :file_name
+
+      # Destination folder path
+      sig { returns(T.nilable(String)) }
+      attr_reader :folder
+
+      sig { params(folder: String).void }
+      attr_writer :folder
+
+      # JSON string of metadata object
+      sig { returns(T.nilable(String)) }
+      attr_reader :metadata
+
+      sig { params(metadata: String).void }
+      attr_writer :metadata
+
+      # true/false to append random suffix
+      sig { returns(T.nilable(String)) }
+      attr_reader :random_prefix
+
+      sig { params(random_prefix: String).void }
+      attr_writer :random_prefix
+
+      # Comma-separated tags
+      sig { returns(T.nilable(String)) }
+      attr_reader :tags
+
+      sig { params(tags: String).void }
+      attr_writer :tags
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :webhook_url
+
+      sig { params(webhook_url: String).void }
+      attr_writer :webhook_url
+
+      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(T.attached_class)
+      end
+      def self.new(
+        # 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
+
+      sig do
+        override.returns(
+          {
+            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
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/autorender/models/upload_create_from_url_response.rbi

@@ -0,0 +1,174 @@
+# typed: strong
+
+module Autorender
+  module Models
+    class UploadCreateFromURLResponse < Autorender::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Autorender::Models::UploadCreateFromURLResponse,
+            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/upload_create_params.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module Autorender
+  module Models
+    class UploadCreateParams < Autorender::Internal::Type::BaseModel
+      extend Autorender::Internal::Type::RequestParameters::Converter
+      include Autorender::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Autorender::UploadCreateParams, Autorender::Internal::AnyHash)
+        end
+
+      # File to upload.
+      sig { returns(Autorender::Internal::FileInput) }
+      attr_accessor :file
+
+      # File name (e.g. product.jpg)
+      sig { returns(String) }
+      attr_accessor :file_name
+
+      # Custom identifier
+      sig { returns(T.nilable(String)) }
+      attr_reader :custom_id
+
+      sig { params(custom_id: String).void }
+      attr_writer :custom_id
+
+      # Optional folder path
+      sig { returns(T.nilable(String)) }
+      attr_reader :folder
+
+      sig { params(folder: String).void }
+      attr_writer :folder
+
+      # JSON string of metadata
+      sig { returns(T.nilable(String)) }
+      attr_reader :metadata
+
+      sig { params(metadata: String).void }
+      attr_writer :metadata
+
+      # true/false to append random suffix
+      sig { returns(T.nilable(String)) }
+      attr_reader :random_prefix
+
+      sig { params(random_prefix: String).void }
+      attr_writer :random_prefix
+
+      # Comma-separated tags
+      sig { returns(T.nilable(String)) }
+      attr_reader :tags
+
+      sig { params(tags: String).void }
+      attr_writer :tags
+
+      # Transform string (w_300,h_300,c_crop,...)
+      sig { returns(T.nilable(String)) }
+      attr_reader :transform
+
+      sig { params(transform: String).void }
+      attr_writer :transform
+
+      # URL to notify on success
+      sig { returns(T.nilable(String)) }
+      attr_reader :webhook_url
+
+      sig { params(webhook_url: String).void }
+      attr_writer :webhook_url
+
+      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(T.attached_class)
+      end
+      def self.new(
+        # 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
+
+      sig do
+        override.returns(
+          {
+            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
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end