appwrite 2.2.0 → 3.0.0

data/lib/appwrite/models/execution_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class ExecutionList
+            attr_reader :sum
+            attr_reader :executions
+
+            def initialize(
+                sum:,
+                executions:
+            )
+                @sum = sum
+                @executions = executions
+            end
+
+            def self.from(map:)
+                ExecutionList.new(
+                    sum: map["sum"],
+                    executions: map["executions"].map { |it| Execution.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "sum": @sum,
+                    "executions": @executions.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/file.rb

@@ -0,0 +1,62 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class File
+            attr_reader :id
+            attr_reader :read
+            attr_reader :write
+            attr_reader :name
+            attr_reader :date_created
+            attr_reader :signature
+            attr_reader :mime_type
+            attr_reader :size_original
+
+            def initialize(
+                id:,
+                read:,
+                write:,
+                name:,
+                date_created:,
+                signature:,
+                mime_type:,
+                size_original:
+            )
+                @id = id
+                @read = read
+                @write = write
+                @name = name
+                @date_created = date_created
+                @signature = signature
+                @mime_type = mime_type
+                @size_original = size_original
+            end
+
+            def self.from(map:)
+                File.new(
+                    id: map["$id"],
+                    read: map["$read"],
+                    write: map["$write"],
+                    name: map["name"],
+                    date_created: map["dateCreated"],
+                    signature: map["signature"],
+                    mime_type: map["mimeType"],
+                    size_original: map["sizeOriginal"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$read": @read,
+                    "$write": @write,
+                    "name": @name,
+                    "dateCreated": @date_created,
+                    "signature": @signature,
+                    "mimeType": @mime_type,
+                    "sizeOriginal": @size_original
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/file_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class FileList
+            attr_reader :sum
+            attr_reader :files
+
+            def initialize(
+                sum:,
+                files:
+            )
+                @sum = sum
+                @files = files
+            end
+
+            def self.from(map:)
+                FileList.new(
+                    sum: map["sum"],
+                    files: map["files"].map { |it| File.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "sum": @sum,
+                    "files": @files.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/function.rb

@@ -0,0 +1,92 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Function
+            attr_reader :id
+            attr_reader :execute
+            attr_reader :name
+            attr_reader :date_created
+            attr_reader :date_updated
+            attr_reader :status
+            attr_reader :runtime
+            attr_reader :tag
+            attr_reader :vars
+            attr_reader :events
+            attr_reader :schedule
+            attr_reader :schedule_next
+            attr_reader :schedule_previous
+            attr_reader :timeout
+
+            def initialize(
+                id:,
+                execute:,
+                name:,
+                date_created:,
+                date_updated:,
+                status:,
+                runtime:,
+                tag:,
+                vars:,
+                events:,
+                schedule:,
+                schedule_next:,
+                schedule_previous:,
+                timeout:
+            )
+                @id = id
+                @execute = execute
+                @name = name
+                @date_created = date_created
+                @date_updated = date_updated
+                @status = status
+                @runtime = runtime
+                @tag = tag
+                @vars = vars
+                @events = events
+                @schedule = schedule
+                @schedule_next = schedule_next
+                @schedule_previous = schedule_previous
+                @timeout = timeout
+            end
+
+            def self.from(map:)
+                Function.new(
+                    id: map["$id"],
+                    execute: map["execute"],
+                    name: map["name"],
+                    date_created: map["dateCreated"],
+                    date_updated: map["dateUpdated"],
+                    status: map["status"],
+                    runtime: map["runtime"],
+                    tag: map["tag"],
+                    vars: map["vars"],
+                    events: map["events"],
+                    schedule: map["schedule"],
+                    schedule_next: map["scheduleNext"],
+                    schedule_previous: map["schedulePrevious"],
+                    timeout: map["timeout"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "execute": @execute,
+                    "name": @name,
+                    "dateCreated": @date_created,
+                    "dateUpdated": @date_updated,
+                    "status": @status,
+                    "runtime": @runtime,
+                    "tag": @tag,
+                    "vars": @vars,
+                    "events": @events,
+                    "schedule": @schedule,
+                    "scheduleNext": @schedule_next,
+                    "schedulePrevious": @schedule_previous,
+                    "timeout": @timeout
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/function_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class FunctionList
+            attr_reader :sum
+            attr_reader :functions
+
+            def initialize(
+                sum:,
+                functions:
+            )
+                @sum = sum
+                @functions = functions
+            end
+
+            def self.from(map:)
+                FunctionList.new(
+                    sum: map["sum"],
+                    functions: map["functions"].map { |it| Function.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "sum": @sum,
+                    "functions": @functions.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/health_antivirus.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class HealthAntivirus
+            attr_reader :version
+            attr_reader :status
+
+            def initialize(
+                version:,
+                status:
+            )
+                @version = version
+                @status = status
+            end
+
+            def self.from(map:)
+                HealthAntivirus.new(
+                    version: map["version"],
+                    status: map["status"]
+                )
+            end
+
+            def to_map
+                {
+                    "version": @version,
+                    "status": @status
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/health_queue.rb

@@ -0,0 +1,27 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class HealthQueue
+            attr_reader :size
+
+            def initialize(
+                size:
+            )
+                @size = size
+            end
+
+            def self.from(map:)
+                HealthQueue.new(
+                    size: map["size"]
+                )
+            end
+
+            def to_map
+                {
+                    "size": @size
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/health_status.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class HealthStatus
+            attr_reader :ping
+            attr_reader :status
+
+            def initialize(
+                ping:,
+                status:
+            )
+                @ping = ping
+                @status = status
+            end
+
+            def self.from(map:)
+                HealthStatus.new(
+                    ping: map["ping"],
+                    status: map["status"]
+                )
+            end
+
+            def to_map
+                {
+                    "ping": @ping,
+                    "status": @status
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/health_time.rb

@@ -0,0 +1,37 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class HealthTime
+            attr_reader :remote_time
+            attr_reader :local_time
+            attr_reader :diff
+
+            def initialize(
+                remote_time:,
+                local_time:,
+                diff:
+            )
+                @remote_time = remote_time
+                @local_time = local_time
+                @diff = diff
+            end
+
+            def self.from(map:)
+                HealthTime.new(
+                    remote_time: map["remoteTime"],
+                    local_time: map["localTime"],
+                    diff: map["diff"]
+                )
+            end
+
+            def to_map
+                {
+                    "remoteTime": @remote_time,
+                    "localTime": @local_time,
+                    "diff": @diff
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/index.rb

@@ -0,0 +1,47 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Index
+            attr_reader :key
+            attr_reader :type
+            attr_reader :status
+            attr_reader :attributes
+            attr_reader :orders
+
+            def initialize(
+                key:,
+                type:,
+                status:,
+                attributes:,
+                orders:
+            )
+                @key = key
+                @type = type
+                @status = status
+                @attributes = attributes
+                @orders = orders
+            end
+
+            def self.from(map:)
+                Index.new(
+                    key: map["key"],
+                    type: map["type"],
+                    status: map["status"],
+                    attributes: map["attributes"],
+                    orders: map["orders"]
+                )
+            end
+
+            def to_map
+                {
+                    "key": @key,
+                    "type": @type,
+                    "status": @status,
+                    "attributes": @attributes,
+                    "orders": @orders
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/index_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class IndexList
+            attr_reader :sum
+            attr_reader :indexes
+
+            def initialize(
+                sum:,
+                indexes:
+            )
+                @sum = sum
+                @indexes = indexes
+            end
+
+            def self.from(map:)
+                IndexList.new(
+                    sum: map["sum"],
+                    indexes: map["indexes"].map { |it| Index.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "sum": @sum,
+                    "indexes": @indexes.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/language.rb

@@ -0,0 +1,37 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Language
+            attr_reader :name
+            attr_reader :code
+            attr_reader :native_name
+
+            def initialize(
+                name:,
+                code:,
+                native_name:
+            )
+                @name = name
+                @code = code
+                @native_name = native_name
+            end
+
+            def self.from(map:)
+                Language.new(
+                    name: map["name"],
+                    code: map["code"],
+                    native_name: map["nativeName"]
+                )
+            end
+
+            def to_map
+                {
+                    "name": @name,
+                    "code": @code,
+                    "nativeName": @native_name
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/language_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class LanguageList
+            attr_reader :sum
+            attr_reader :languages
+
+            def initialize(
+                sum:,
+                languages:
+            )
+                @sum = sum
+                @languages = languages
+            end
+
+            def self.from(map:)
+                LanguageList.new(
+                    sum: map["sum"],
+                    languages: map["languages"].map { |it| Language.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "sum": @sum,
+                    "languages": @languages.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/locale.rb

@@ -0,0 +1,57 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Locale
+            attr_reader :ip
+            attr_reader :country_code
+            attr_reader :country
+            attr_reader :continent_code
+            attr_reader :continent
+            attr_reader :eu
+            attr_reader :currency
+
+            def initialize(
+                ip:,
+                country_code:,
+                country:,
+                continent_code:,
+                continent:,
+                eu:,
+                currency:
+            )
+                @ip = ip
+                @country_code = country_code
+                @country = country
+                @continent_code = continent_code
+                @continent = continent
+                @eu = eu
+                @currency = currency
+            end
+
+            def self.from(map:)
+                Locale.new(
+                    ip: map["ip"],
+                    country_code: map["countryCode"],
+                    country: map["country"],
+                    continent_code: map["continentCode"],
+                    continent: map["continent"],
+                    eu: map["eu"],
+                    currency: map["currency"]
+                )
+            end
+
+            def to_map
+                {
+                    "ip": @ip,
+                    "countryCode": @country_code,
+                    "country": @country,
+                    "continentCode": @continent_code,
+                    "continent": @continent,
+                    "eu": @eu,
+                    "currency": @currency
+                }
+            end
+        end
+    end
+end