appwrite 26.0.0 → 27.0.0

data/lib/appwrite/models/database_status.rb

@@ -0,0 +1,92 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DatabaseStatus
+            attr_reader :health
+            attr_reader :ready
+            attr_reader :engine
+            attr_reader :version
+            attr_reader :uptime
+            attr_reader :connections
+            attr_reader :sync_mode
+            attr_reader :effective_sync_mode
+            attr_reader :sync_degraded
+            attr_reader :sync_acknowledgements
+            attr_reader :sync_standby_count
+            attr_reader :sync_state_confirmed
+            attr_reader :replicas
+            attr_reader :volumes
+
+            def initialize(
+                health:,
+                ready:,
+                engine:,
+                version:,
+                uptime:,
+                connections:,
+                sync_mode:,
+                effective_sync_mode: ,
+                sync_degraded:,
+                sync_acknowledgements:,
+                sync_standby_count:,
+                sync_state_confirmed: ,
+                replicas:,
+                volumes:
+            )
+                @health = health
+                @ready = ready
+                @engine = engine
+                @version = version
+                @uptime = uptime
+                @connections = connections
+                @sync_mode = sync_mode
+                @effective_sync_mode = effective_sync_mode
+                @sync_degraded = sync_degraded
+                @sync_acknowledgements = sync_acknowledgements
+                @sync_standby_count = sync_standby_count
+                @sync_state_confirmed = sync_state_confirmed
+                @replicas = replicas
+                @volumes = volumes
+            end
+
+            def self.from(map:)
+                DatabaseStatus.new(
+                    health: map["health"],
+                    ready: map["ready"],
+                    engine: map["engine"],
+                    version: map["version"],
+                    uptime: map["uptime"],
+                    connections: DatabaseStatusConnections.from(map: map["connections"]),
+                    sync_mode: map["syncMode"],
+                    effective_sync_mode: map["effectiveSyncMode"],
+                    sync_degraded: map["syncDegraded"],
+                    sync_acknowledgements: map["syncAcknowledgements"],
+                    sync_standby_count: map["syncStandbyCount"],
+                    sync_state_confirmed: map["syncStateConfirmed"],
+                    replicas: map["replicas"].map { |it| DatabaseStatusReplica.from(map: it) },
+                    volumes: map["volumes"].map { |it| DatabaseStatusVolume.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "health": @health,
+                    "ready": @ready,
+                    "engine": @engine,
+                    "version": @version,
+                    "uptime": @uptime,
+                    "connections": @connections.to_map,
+                    "syncMode": @sync_mode,
+                    "effectiveSyncMode": @effective_sync_mode,
+                    "syncDegraded": @sync_degraded,
+                    "syncAcknowledgements": @sync_acknowledgements,
+                    "syncStandbyCount": @sync_standby_count,
+                    "syncStateConfirmed": @sync_state_confirmed,
+                    "replicas": @replicas.map { |it| it.to_map },
+                    "volumes": @volumes.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/database_status_connections.rb

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

data/lib/appwrite/models/database_status_replica.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DatabaseStatusReplica
+            attr_reader :index
+            attr_reader :role
+            attr_reader :healthy
+            attr_reader :lag_seconds
+
+            def initialize(
+                index:,
+                role:,
+                healthy:,
+                lag_seconds: 
+            )
+                @index = index
+                @role = role
+                @healthy = healthy
+                @lag_seconds = lag_seconds
+            end
+
+            def self.from(map:)
+                DatabaseStatusReplica.new(
+                    index: map["index"],
+                    role: map["role"],
+                    healthy: map["healthy"],
+                    lag_seconds: map["lagSeconds"]
+                )
+            end
+
+            def to_map
+                {
+                    "index": @index,
+                    "role": @role,
+                    "healthy": @healthy,
+                    "lagSeconds": @lag_seconds
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/database_status_volume.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DatabaseStatusVolume
+            attr_reader :xpath
+            attr_reader :used_percent
+            attr_reader :available
+            attr_reader :mounted
+
+            def initialize(
+                xpath:,
+                used_percent:,
+                available:,
+                mounted:
+            )
+                @xpath = xpath
+                @used_percent = used_percent
+                @available = available
+                @mounted = mounted
+            end
+
+            def self.from(map:)
+                DatabaseStatusVolume.new(
+                    xpath: map["path"],
+                    used_percent: map["usedPercent"],
+                    available: map["available"],
+                    mounted: map["mounted"]
+                )
+            end
+
+            def to_map
+                {
+                    "path": @xpath,
+                    "usedPercent": @used_percent,
+                    "available": @available,
+                    "mounted": @mounted
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database.rb

@@ -0,0 +1,262 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabase
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :project_id
+            attr_reader :name
+            attr_reader :api
+            attr_reader :engine
+            attr_reader :version
+            attr_reader :specification
+            attr_reader :backend
+            attr_reader :hostname
+            attr_reader :connection_port
+            attr_reader :connection_user
+            attr_reader :connection_password
+            attr_reader :connection_string
+            attr_reader :ssl
+            attr_reader :status
+            attr_reader :container_status
+            attr_reader :last_accessed_at
+            attr_reader :idle_until
+            attr_reader :lifecycle_state
+            attr_reader :idle_timeout_minutes
+            attr_reader :cpu
+            attr_reader :memory
+            attr_reader :storage
+            attr_reader :storage_class
+            attr_reader :storage_max_gb
+            attr_reader :node_pool
+            attr_reader :replicas
+            attr_reader :sync_mode
+            attr_reader :network_max_connections
+            attr_reader :network_idle_timeout_seconds
+            attr_reader :network_ip_allowlist
+            attr_reader :backup_enabled
+            attr_reader :pitr
+            attr_reader :pitr_retention_days
+            attr_reader :storage_autoscaling
+            attr_reader :storage_autoscaling_threshold_percent
+            attr_reader :storage_autoscaling_max_gb
+            attr_reader :maintenance_window_day
+            attr_reader :maintenance_window_hour_utc
+            attr_reader :metrics_enabled
+            attr_reader :sql_api_enabled
+            attr_reader :sql_api_allowed_statements
+            attr_reader :sql_api_max_rows
+            attr_reader :sql_api_max_bytes
+            attr_reader :sql_api_timeout_seconds
+            attr_reader :error
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                project_id:,
+                name:,
+                api:,
+                engine:,
+                version:,
+                specification:,
+                backend:,
+                hostname:,
+                connection_port:,
+                connection_user:,
+                connection_password:,
+                connection_string:,
+                ssl:,
+                status:,
+                container_status:,
+                last_accessed_at: ,
+                idle_until: ,
+                lifecycle_state:,
+                idle_timeout_minutes:,
+                cpu:,
+                memory:,
+                storage:,
+                storage_class:,
+                storage_max_gb:,
+                node_pool:,
+                replicas:,
+                sync_mode:,
+                network_max_connections:,
+                network_idle_timeout_seconds:,
+                network_ip_allowlist:,
+                backup_enabled:,
+                pitr:,
+                pitr_retention_days:,
+                storage_autoscaling:,
+                storage_autoscaling_threshold_percent:,
+                storage_autoscaling_max_gb:,
+                maintenance_window_day:,
+                maintenance_window_hour_utc:,
+                metrics_enabled:,
+                sql_api_enabled:,
+                sql_api_allowed_statements:,
+                sql_api_max_rows:,
+                sql_api_max_bytes:,
+                sql_api_timeout_seconds:,
+                error:
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @project_id = project_id
+                @name = name
+                @api = api
+                @engine = engine
+                @version = version
+                @specification = specification
+                @backend = backend
+                @hostname = hostname
+                @connection_port = connection_port
+                @connection_user = connection_user
+                @connection_password = connection_password
+                @connection_string = connection_string
+                @ssl = ssl
+                @status = status
+                @container_status = container_status
+                @last_accessed_at = last_accessed_at
+                @idle_until = idle_until
+                @lifecycle_state = lifecycle_state
+                @idle_timeout_minutes = idle_timeout_minutes
+                @cpu = cpu
+                @memory = memory
+                @storage = storage
+                @storage_class = storage_class
+                @storage_max_gb = storage_max_gb
+                @node_pool = node_pool
+                @replicas = replicas
+                @sync_mode = sync_mode
+                @network_max_connections = network_max_connections
+                @network_idle_timeout_seconds = network_idle_timeout_seconds
+                @network_ip_allowlist = network_ip_allowlist
+                @backup_enabled = backup_enabled
+                @pitr = pitr
+                @pitr_retention_days = pitr_retention_days
+                @storage_autoscaling = storage_autoscaling
+                @storage_autoscaling_threshold_percent = storage_autoscaling_threshold_percent
+                @storage_autoscaling_max_gb = storage_autoscaling_max_gb
+                @maintenance_window_day = maintenance_window_day
+                @maintenance_window_hour_utc = maintenance_window_hour_utc
+                @metrics_enabled = metrics_enabled
+                @sql_api_enabled = sql_api_enabled
+                @sql_api_allowed_statements = sql_api_allowed_statements
+                @sql_api_max_rows = sql_api_max_rows
+                @sql_api_max_bytes = sql_api_max_bytes
+                @sql_api_timeout_seconds = sql_api_timeout_seconds
+                @error = error
+            end
+
+            def self.from(map:)
+                DedicatedDatabase.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    project_id: map["projectId"],
+                    name: map["name"],
+                    api: map["api"],
+                    engine: map["engine"],
+                    version: map["version"],
+                    specification: map["specification"],
+                    backend: map["backend"],
+                    hostname: map["hostname"],
+                    connection_port: map["connectionPort"],
+                    connection_user: map["connectionUser"],
+                    connection_password: map["connectionPassword"],
+                    connection_string: map["connectionString"],
+                    ssl: map["ssl"],
+                    status: map["status"],
+                    container_status: map["containerStatus"],
+                    last_accessed_at: map["lastAccessedAt"],
+                    idle_until: map["idleUntil"],
+                    lifecycle_state: map["lifecycleState"],
+                    idle_timeout_minutes: map["idleTimeoutMinutes"],
+                    cpu: map["cpu"],
+                    memory: map["memory"],
+                    storage: map["storage"],
+                    storage_class: map["storageClass"],
+                    storage_max_gb: map["storageMaxGb"],
+                    node_pool: map["nodePool"],
+                    replicas: map["replicas"],
+                    sync_mode: map["syncMode"],
+                    network_max_connections: map["networkMaxConnections"],
+                    network_idle_timeout_seconds: map["networkIdleTimeoutSeconds"],
+                    network_ip_allowlist: map["networkIPAllowlist"],
+                    backup_enabled: map["backupEnabled"],
+                    pitr: map["pitr"],
+                    pitr_retention_days: map["pitrRetentionDays"],
+                    storage_autoscaling: map["storageAutoscaling"],
+                    storage_autoscaling_threshold_percent: map["storageAutoscalingThresholdPercent"],
+                    storage_autoscaling_max_gb: map["storageAutoscalingMaxGb"],
+                    maintenance_window_day: map["maintenanceWindowDay"],
+                    maintenance_window_hour_utc: map["maintenanceWindowHourUtc"],
+                    metrics_enabled: map["metricsEnabled"],
+                    sql_api_enabled: map["sqlApiEnabled"],
+                    sql_api_allowed_statements: map["sqlApiAllowedStatements"],
+                    sql_api_max_rows: map["sqlApiMaxRows"],
+                    sql_api_max_bytes: map["sqlApiMaxBytes"],
+                    sql_api_timeout_seconds: map["sqlApiTimeoutSeconds"],
+                    error: map["error"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "projectId": @project_id,
+                    "name": @name,
+                    "api": @api,
+                    "engine": @engine,
+                    "version": @version,
+                    "specification": @specification,
+                    "backend": @backend,
+                    "hostname": @hostname,
+                    "connectionPort": @connection_port,
+                    "connectionUser": @connection_user,
+                    "connectionPassword": @connection_password,
+                    "connectionString": @connection_string,
+                    "ssl": @ssl,
+                    "status": @status,
+                    "containerStatus": @container_status,
+                    "lastAccessedAt": @last_accessed_at,
+                    "idleUntil": @idle_until,
+                    "lifecycleState": @lifecycle_state,
+                    "idleTimeoutMinutes": @idle_timeout_minutes,
+                    "cpu": @cpu,
+                    "memory": @memory,
+                    "storage": @storage,
+                    "storageClass": @storage_class,
+                    "storageMaxGb": @storage_max_gb,
+                    "nodePool": @node_pool,
+                    "replicas": @replicas,
+                    "syncMode": @sync_mode,
+                    "networkMaxConnections": @network_max_connections,
+                    "networkIdleTimeoutSeconds": @network_idle_timeout_seconds,
+                    "networkIPAllowlist": @network_ip_allowlist,
+                    "backupEnabled": @backup_enabled,
+                    "pitr": @pitr,
+                    "pitrRetentionDays": @pitr_retention_days,
+                    "storageAutoscaling": @storage_autoscaling,
+                    "storageAutoscalingThresholdPercent": @storage_autoscaling_threshold_percent,
+                    "storageAutoscalingMaxGb": @storage_autoscaling_max_gb,
+                    "maintenanceWindowDay": @maintenance_window_day,
+                    "maintenanceWindowHourUtc": @maintenance_window_hour_utc,
+                    "metricsEnabled": @metrics_enabled,
+                    "sqlApiEnabled": @sql_api_enabled,
+                    "sqlApiAllowedStatements": @sql_api_allowed_statements,
+                    "sqlApiMaxRows": @sql_api_max_rows,
+                    "sqlApiMaxBytes": @sql_api_max_bytes,
+                    "sqlApiTimeoutSeconds": @sql_api_timeout_seconds,
+                    "error": @error
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_member.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseMember
+            attr_reader :id
+            attr_reader :role
+            attr_reader :status
+            attr_reader :lag_seconds
+
+            def initialize(
+                id:,
+                role:,
+                status:,
+                lag_seconds: 
+            )
+                @id = id
+                @role = role
+                @status = status
+                @lag_seconds = lag_seconds
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseMember.new(
+                    id: map["$id"],
+                    role: map["role"],
+                    status: map["status"],
+                    lag_seconds: map["lagSeconds"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "role": @role,
+                    "status": @status,
+                    "lagSeconds": @lag_seconds
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_operation.rb

@@ -0,0 +1,77 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseOperation
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :database_id
+            attr_reader :type
+            attr_reader :status
+            attr_reader :attempts
+            attr_reader :requested_at
+            attr_reader :started_at
+            attr_reader :completed_at
+            attr_reader :error_code
+            attr_reader :error_message
+
+            def initialize(
+                id:,
+                created_at:,
+                database_id:,
+                type:,
+                status:,
+                attempts:,
+                requested_at: ,
+                started_at: ,
+                completed_at: ,
+                error_code:,
+                error_message:
+            )
+                @id = id
+                @created_at = created_at
+                @database_id = database_id
+                @type = type
+                @status = status
+                @attempts = attempts
+                @requested_at = requested_at
+                @started_at = started_at
+                @completed_at = completed_at
+                @error_code = error_code
+                @error_message = error_message
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseOperation.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    database_id: map["databaseId"],
+                    type: map["type"],
+                    status: map["status"],
+                    attempts: map["attempts"],
+                    requested_at: map["requestedAt"],
+                    started_at: map["startedAt"],
+                    completed_at: map["completedAt"],
+                    error_code: map["errorCode"],
+                    error_message: map["errorMessage"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "databaseId": @database_id,
+                    "type": @type,
+                    "status": @status,
+                    "attempts": @attempts,
+                    "requestedAt": @requested_at,
+                    "startedAt": @started_at,
+                    "completedAt": @completed_at,
+                    "errorCode": @error_code,
+                    "errorMessage": @error_message
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_operation_list.rb

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

data/lib/appwrite/models/dedicated_database_replicas.rb

@@ -0,0 +1,62 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseReplicas
+            attr_reader :replicas
+            attr_reader :sync_mode
+            attr_reader :effective_sync_mode
+            attr_reader :sync_degraded
+            attr_reader :sync_acknowledgements
+            attr_reader :sync_standby_count
+            attr_reader :sync_state_confirmed
+            attr_reader :members
+
+            def initialize(
+                replicas:,
+                sync_mode:,
+                effective_sync_mode: ,
+                sync_degraded:,
+                sync_acknowledgements:,
+                sync_standby_count:,
+                sync_state_confirmed: ,
+                members:
+            )
+                @replicas = replicas
+                @sync_mode = sync_mode
+                @effective_sync_mode = effective_sync_mode
+                @sync_degraded = sync_degraded
+                @sync_acknowledgements = sync_acknowledgements
+                @sync_standby_count = sync_standby_count
+                @sync_state_confirmed = sync_state_confirmed
+                @members = members
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseReplicas.new(
+                    replicas: map["replicas"],
+                    sync_mode: map["syncMode"],
+                    effective_sync_mode: map["effectiveSyncMode"],
+                    sync_degraded: map["syncDegraded"],
+                    sync_acknowledgements: map["syncAcknowledgements"],
+                    sync_standby_count: map["syncStandbyCount"],
+                    sync_state_confirmed: map["syncStateConfirmed"],
+                    members: map["members"].map { |it| DedicatedDatabaseMember.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "replicas": @replicas,
+                    "syncMode": @sync_mode,
+                    "effectiveSyncMode": @effective_sync_mode,
+                    "syncDegraded": @sync_degraded,
+                    "syncAcknowledgements": @sync_acknowledgements,
+                    "syncStandbyCount": @sync_standby_count,
+                    "syncStateConfirmed": @sync_state_confirmed,
+                    "members": @members.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end