appwrite 2.4.1 → 4.1.0

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 :total
+            attr_reader :indexes
+
+            def initialize(
+                total:,
+                indexes:
+            )
+                @total = total
+                @indexes = indexes
+            end
+
+            def self.from(map:)
+                IndexList.new(
+                    total: map["total"],
+                    indexes: map["indexes"].map { |it| Index.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "total": @total,
+                    "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 :total
+            attr_reader :languages
+
+            def initialize(
+                total:,
+                languages:
+            )
+                @total = total
+                @languages = languages
+            end
+
+            def self.from(map:)
+                LanguageList.new(
+                    total: map["total"],
+                    languages: map["languages"].map { |it| Language.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "total": @total,
+                    "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

data/lib/appwrite/models/log.rb

@@ -0,0 +1,127 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Log
+            attr_reader :event
+            attr_reader :user_id
+            attr_reader :user_email
+            attr_reader :user_name
+            attr_reader :mode
+            attr_reader :ip
+            attr_reader :time
+            attr_reader :os_code
+            attr_reader :os_name
+            attr_reader :os_version
+            attr_reader :client_type
+            attr_reader :client_code
+            attr_reader :client_name
+            attr_reader :client_version
+            attr_reader :client_engine
+            attr_reader :client_engine_version
+            attr_reader :device_name
+            attr_reader :device_brand
+            attr_reader :device_model
+            attr_reader :country_code
+            attr_reader :country_name
+
+            def initialize(
+                event:,
+                user_id:,
+                user_email:,
+                user_name:,
+                mode:,
+                ip:,
+                time:,
+                os_code:,
+                os_name:,
+                os_version:,
+                client_type:,
+                client_code:,
+                client_name:,
+                client_version:,
+                client_engine:,
+                client_engine_version:,
+                device_name:,
+                device_brand:,
+                device_model:,
+                country_code:,
+                country_name:
+            )
+                @event = event
+                @user_id = user_id
+                @user_email = user_email
+                @user_name = user_name
+                @mode = mode
+                @ip = ip
+                @time = time
+                @os_code = os_code
+                @os_name = os_name
+                @os_version = os_version
+                @client_type = client_type
+                @client_code = client_code
+                @client_name = client_name
+                @client_version = client_version
+                @client_engine = client_engine
+                @client_engine_version = client_engine_version
+                @device_name = device_name
+                @device_brand = device_brand
+                @device_model = device_model
+                @country_code = country_code
+                @country_name = country_name
+            end
+
+            def self.from(map:)
+                Log.new(
+                    event: map["event"],
+                    user_id: map["userId"],
+                    user_email: map["userEmail"],
+                    user_name: map["userName"],
+                    mode: map["mode"],
+                    ip: map["ip"],
+                    time: map["time"],
+                    os_code: map["osCode"],
+                    os_name: map["osName"],
+                    os_version: map["osVersion"],
+                    client_type: map["clientType"],
+                    client_code: map["clientCode"],
+                    client_name: map["clientName"],
+                    client_version: map["clientVersion"],
+                    client_engine: map["clientEngine"],
+                    client_engine_version: map["clientEngineVersion"],
+                    device_name: map["deviceName"],
+                    device_brand: map["deviceBrand"],
+                    device_model: map["deviceModel"],
+                    country_code: map["countryCode"],
+                    country_name: map["countryName"]
+                )
+            end
+
+            def to_map
+                {
+                    "event": @event,
+                    "userId": @user_id,
+                    "userEmail": @user_email,
+                    "userName": @user_name,
+                    "mode": @mode,
+                    "ip": @ip,
+                    "time": @time,
+                    "osCode": @os_code,
+                    "osName": @os_name,
+                    "osVersion": @os_version,
+                    "clientType": @client_type,
+                    "clientCode": @client_code,
+                    "clientName": @client_name,
+                    "clientVersion": @client_version,
+                    "clientEngine": @client_engine,
+                    "clientEngineVersion": @client_engine_version,
+                    "deviceName": @device_name,
+                    "deviceBrand": @device_brand,
+                    "deviceModel": @device_model,
+                    "countryCode": @country_code,
+                    "countryName": @country_name
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/log_list.rb

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

data/lib/appwrite/models/membership.rb

@@ -0,0 +1,67 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Membership
+            attr_reader :id
+            attr_reader :user_id
+            attr_reader :team_id
+            attr_reader :name
+            attr_reader :email
+            attr_reader :invited
+            attr_reader :joined
+            attr_reader :confirm
+            attr_reader :roles
+
+            def initialize(
+                id:,
+                user_id:,
+                team_id:,
+                name:,
+                email:,
+                invited:,
+                joined:,
+                confirm:,
+                roles:
+            )
+                @id = id
+                @user_id = user_id
+                @team_id = team_id
+                @name = name
+                @email = email
+                @invited = invited
+                @joined = joined
+                @confirm = confirm
+                @roles = roles
+            end
+
+            def self.from(map:)
+                Membership.new(
+                    id: map["$id"],
+                    user_id: map["userId"],
+                    team_id: map["teamId"],
+                    name: map["name"],
+                    email: map["email"],
+                    invited: map["invited"],
+                    joined: map["joined"],
+                    confirm: map["confirm"],
+                    roles: map["roles"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "userId": @user_id,
+                    "teamId": @team_id,
+                    "name": @name,
+                    "email": @email,
+                    "invited": @invited,
+                    "joined": @joined,
+                    "confirm": @confirm,
+                    "roles": @roles
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/membership_list.rb

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

data/lib/appwrite/models/phone.rb

@@ -0,0 +1,37 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Phone
+            attr_reader :code
+            attr_reader :country_code
+            attr_reader :country_name
+
+            def initialize(
+                code:,
+                country_code:,
+                country_name:
+            )
+                @code = code
+                @country_code = country_code
+                @country_name = country_name
+            end
+
+            def self.from(map:)
+                Phone.new(
+                    code: map["code"],
+                    country_code: map["countryCode"],
+                    country_name: map["countryName"]
+                )
+            end
+
+            def to_map
+                {
+                    "code": @code,
+                    "countryCode": @country_code,
+                    "countryName": @country_name
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/phone_list.rb

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

data/lib/appwrite/models/preferences.rb

@@ -0,0 +1,30 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Preferences
+
+            def initialize(
+                data:
+            )
+                @data = data
+            end
+
+            def self.from(map:)
+                Preferences.new(
+                    data: map["data"]
+                )
+            end
+
+            def to_map
+                {
+                    "data": @data
+                }
+            end
+
+            def convert_to(from_json)
+                from_json.call(data)
+            end
+        end
+    end
+end

data/lib/appwrite/models/runtime.rb

@@ -0,0 +1,57 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Runtime
+            attr_reader :id
+            attr_reader :name
+            attr_reader :version
+            attr_reader :base
+            attr_reader :image
+            attr_reader :logo
+            attr_reader :supports
+
+            def initialize(
+                id:,
+                name:,
+                version:,
+                base:,
+                image:,
+                logo:,
+                supports:
+            )
+                @id = id
+                @name = name
+                @version = version
+                @base = base
+                @image = image
+                @logo = logo
+                @supports = supports
+            end
+
+            def self.from(map:)
+                Runtime.new(
+                    id: map["$id"],
+                    name: map["name"],
+                    version: map["version"],
+                    base: map["base"],
+                    image: map["image"],
+                    logo: map["logo"],
+                    supports: map["supports"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "name": @name,
+                    "version": @version,
+                    "base": @base,
+                    "image": @image,
+                    "logo": @logo,
+                    "supports": @supports
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/runtime_list.rb

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