appwrite 26.1.0 → 28.0.0.rc1

data/lib/appwrite/models/dedicated_database_branch_list.rb

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

data/lib/appwrite/models/dedicated_database_execution.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseExecution
+            attr_reader :rows
+            attr_reader :row_count
+            attr_reader :columns
+            attr_reader :duration_ms
+            attr_reader :truncated
+            attr_reader :bytes
+
+            def initialize(
+                rows:,
+                row_count:,
+                columns:,
+                duration_ms:,
+                truncated:,
+                bytes:
+            )
+                @rows = rows
+                @row_count = row_count
+                @columns = columns
+                @duration_ms = duration_ms
+                @truncated = truncated
+                @bytes = bytes
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseExecution.new(
+                    rows: map["rows"],
+                    row_count: map["rowCount"],
+                    columns: map["columns"].map { |it| DedicatedDatabaseExecutionColumn.from(map: it) },
+                    duration_ms: map["durationMs"],
+                    truncated: map["truncated"],
+                    bytes: map["bytes"]
+                )
+            end
+
+            def to_map
+                {
+                    "rows": @rows,
+                    "rowCount": @row_count,
+                    "columns": @columns.map { |it| it.to_map },
+                    "durationMs": @duration_ms,
+                    "truncated": @truncated,
+                    "bytes": @bytes
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_execution_column.rb

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

data/lib/appwrite/models/dedicated_database_extensions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseExtensions
+            attr_reader :installed
+            attr_reader :available
+            attr_reader :metadata
+
+            def initialize(
+                installed:,
+                available:,
+                metadata:
+            )
+                @installed = installed
+                @available = available
+                @metadata = metadata
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseExtensions.new(
+                    installed: map["installed"],
+                    available: map["available"],
+                    metadata: map["metadata"].map { |it| PostgresExtension.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "installed": @installed,
+                    "available": @available,
+                    "metadata": @metadata.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_list.rb

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

data/lib/appwrite/models/dedicated_database_member.rb

@@ -1,4 +1,4 @@
-#frozen_string_literal: true
+# frozen_string_literal: true
 
 module Appwrite
     module Models
@@ -6,17 +6,20 @@ module Appwrite
             attr_reader :id
             attr_reader :role
             attr_reader :status
+            attr_reader :replicating
             attr_reader :lag_seconds
 
             def initialize(
                 id:,
                 role:,
                 status:,
+                replicating:,
                 lag_seconds:
             )
                 @id = id
                 @role = role
                 @status = status
+                @replicating = replicating
                 @lag_seconds = lag_seconds
             end
 
@@ -25,6 +28,7 @@ module Appwrite
                     id: map["$id"],
                     role: map["role"],
                     status: map["status"],
+                    replicating: map["replicating"],
                     lag_seconds: map["lagSeconds"]
                 )
             end
@@ -34,6 +38,7 @@ module Appwrite
                     "$id": @id,
                     "role": @role,
                     "status": @status,
+                    "replicating": @replicating,
                     "lagSeconds": @lag_seconds
                 }
             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_pitr_windows.rb

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

data/lib/appwrite/models/dedicated_database_pooler.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabasePooler
+            attr_reader :enabled
+            attr_reader :mode
+            attr_reader :max_connections
+            attr_reader :default_pool_size
+            attr_reader :port
+            attr_reader :read_write_splitting
+            attr_reader :pooler_cpu_request
+            attr_reader :pooler_cpu_limit
+            attr_reader :pooler_memory_request
+            attr_reader :pooler_memory_limit
+
+            def initialize(
+                enabled:,
+                mode:,
+                max_connections:,
+                default_pool_size:,
+                port:,
+                read_write_splitting:,
+                pooler_cpu_request:,
+                pooler_cpu_limit:,
+                pooler_memory_request:,
+                pooler_memory_limit:
+            )
+                @enabled = enabled
+                @mode = mode
+                @max_connections = max_connections
+                @default_pool_size = default_pool_size
+                @port = port
+                @read_write_splitting = read_write_splitting
+                @pooler_cpu_request = pooler_cpu_request
+                @pooler_cpu_limit = pooler_cpu_limit
+                @pooler_memory_request = pooler_memory_request
+                @pooler_memory_limit = pooler_memory_limit
+            end
+
+            def self.from(map:)
+                DedicatedDatabasePooler.new(
+                    enabled: map["enabled"],
+                    mode: map["mode"],
+                    max_connections: map["maxConnections"],
+                    default_pool_size: map["defaultPoolSize"],
+                    port: map["port"],
+                    read_write_splitting: map["readWriteSplitting"],
+                    pooler_cpu_request: map["poolerCpuRequest"],
+                    pooler_cpu_limit: map["poolerCpuLimit"],
+                    pooler_memory_request: map["poolerMemoryRequest"],
+                    pooler_memory_limit: map["poolerMemoryLimit"]
+                )
+            end
+
+            def to_map
+                {
+                    "enabled": @enabled,
+                    "mode": @mode,
+                    "maxConnections": @max_connections,
+                    "defaultPoolSize": @default_pool_size,
+                    "port": @port,
+                    "readWriteSplitting": @read_write_splitting,
+                    "poolerCpuRequest": @pooler_cpu_request,
+                    "poolerCpuLimit": @pooler_cpu_limit,
+                    "poolerMemoryRequest": @pooler_memory_request,
+                    "poolerMemoryLimit": @pooler_memory_limit
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_replicas.rb

@@ -1,19 +1,34 @@
-#frozen_string_literal: true
+# 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
 
@@ -21,6 +36,11 @@ module Appwrite
                 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
@@ -29,6 +49,11 @@ module Appwrite
                 {
                     "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

data/lib/appwrite/models/dedicated_database_restoration.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseRestoration
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :database_id
+            attr_reader :source_database_id
+            attr_reader :project_id
+            attr_reader :backup_id
+            attr_reader :type
+            attr_reader :status
+            attr_reader :target_time
+            attr_reader :started_at
+            attr_reader :completed_at
+            attr_reader :error
+
+            def initialize(
+                id:,
+                created_at:,
+                database_id:,
+                source_database_id:,
+                project_id:,
+                backup_id:,
+                type:,
+                status:,
+                target_time:,
+                started_at:,
+                completed_at:,
+                error:
+            )
+                @id = id
+                @created_at = created_at
+                @database_id = database_id
+                @source_database_id = source_database_id
+                @project_id = project_id
+                @backup_id = backup_id
+                @type = type
+                @status = status
+                @target_time = target_time
+                @started_at = started_at
+                @completed_at = completed_at
+                @error = error
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseRestoration.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    database_id: map["databaseId"],
+                    source_database_id: map["sourceDatabaseId"],
+                    project_id: map["projectId"],
+                    backup_id: map["backupId"],
+                    type: map["type"],
+                    status: map["status"],
+                    target_time: map["targetTime"],
+                    started_at: map["startedAt"],
+                    completed_at: map["completedAt"],
+                    error: map["error"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "databaseId": @database_id,
+                    "sourceDatabaseId": @source_database_id,
+                    "projectId": @project_id,
+                    "backupId": @backup_id,
+                    "type": @type,
+                    "status": @status,
+                    "targetTime": @target_time,
+                    "startedAt": @started_at,
+                    "completedAt": @completed_at,
+                    "error": @error
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_restoration_list.rb

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

data/lib/appwrite/models/dedicated_database_specification.rb

@@ -1,4 +1,4 @@
-#frozen_string_literal: true
+# frozen_string_literal: true
 
 module Appwrite
     module Models

data/lib/appwrite/models/dedicated_database_specification_list.rb

@@ -1,4 +1,4 @@
-#frozen_string_literal: true
+# frozen_string_literal: true
 
 module Appwrite
     module Models

data/lib/appwrite/models/dedicated_database_specification_pricing.rb

@@ -1,4 +1,4 @@
-#frozen_string_literal: true
+# frozen_string_literal: true
 
 module Appwrite
     module Models
@@ -6,20 +6,17 @@ module Appwrite
             attr_reader :storage_overage_rate
             attr_reader :bandwidth_overage_rate
             attr_reader :replica_rate
-            attr_reader :cross_region_replica_rate
             attr_reader :pitr_rate
 
             def initialize(
                 storage_overage_rate:,
                 bandwidth_overage_rate:,
                 replica_rate:,
-                cross_region_replica_rate:,
                 pitr_rate:
             )
                 @storage_overage_rate = storage_overage_rate
                 @bandwidth_overage_rate = bandwidth_overage_rate
                 @replica_rate = replica_rate
-                @cross_region_replica_rate = cross_region_replica_rate
                 @pitr_rate = pitr_rate
             end
 
@@ -28,7 +25,6 @@ module Appwrite
                     storage_overage_rate: map["storageOverageRate"],
                     bandwidth_overage_rate: map["bandwidthOverageRate"],
                     replica_rate: map["replicaRate"],
-                    cross_region_replica_rate: map["crossRegionReplicaRate"],
                     pitr_rate: map["pitrRate"]
                 )
             end
@@ -38,7 +34,6 @@ module Appwrite
                     "storageOverageRate": @storage_overage_rate,
                     "bandwidthOverageRate": @bandwidth_overage_rate,
                     "replicaRate": @replica_rate,
-                    "crossRegionReplicaRate": @cross_region_replica_rate,
                     "pitrRate": @pitr_rate
                 }
             end