export declare const ActiveDirectoryAuth: { readonly Enabled: "enabled"; readonly Disabled: "disabled"; }; export type ActiveDirectoryAuth = (typeof ActiveDirectoryAuth)[keyof typeof ActiveDirectoryAuth]; export declare const AdministratorType: { readonly ActiveDirectory: "ActiveDirectory"; }; /** * The type of administrator. */ export type AdministratorType = (typeof AdministratorType)[keyof typeof AdministratorType]; export declare const AzureManagedDiskPerformanceTier: { /** * Entry-level SSD for minimal IOPS, ideal for light development or testing workloads. */ readonly P1: "P1"; /** * Slightly higher IOPS for small-scale applications needing consistent low latency. */ readonly P2: "P2"; /** * Balanced performance for basic production workloads with moderate throughput. */ readonly P3: "P3"; /** * Enhanced IOPS for growing apps with predictable performance needs. */ readonly P4: "P4"; /** * Mid-tier SSD for steady workloads requiring reliable throughput and latency. */ readonly P6: "P6"; /** * Popular choice for general-purpose production workloads with scalable performance. */ readonly P10: "P10"; /** * High IOPS tier for demanding apps with frequent read/write operations. */ readonly P15: "P15"; /** * Entry point for high-performance Solid State Disks (SSDs), suitable for small-scale I/O-intensive workloads. */ readonly P20: "P20"; /** * Balanced tier for moderate throughput and latency-sensitive applications. */ readonly P30: "P30"; /** * Enhanced performance for growing production workloads with consistent IOPS demands. */ readonly P40: "P40"; /** * Optimized for enterprise-grade applications needing sustained high throughput. */ readonly P50: "P50"; /** * High-capacity tier for large databases and analytics workloads with elevated IOPS. */ readonly P60: "P60"; /** * Designed for mission-critical systems requiring ultra-low latency and high concurrency. */ readonly P70: "P70"; /** * Top-tier SSD for maximum IOPS and throughput, ideal for the most demanding workloads. */ readonly P80: "P80"; }; /** * Storage tier of a server. */ export type AzureManagedDiskPerformanceTier = (typeof AzureManagedDiskPerformanceTier)[keyof typeof AzureManagedDiskPerformanceTier]; export declare const Cancel: { /** * Cancel must be triggered for the entire migration. */ readonly True: "True"; /** * Cancel must not be triggered for the entire migration. */ readonly False: "False"; }; /** * Indicates if cancel must be triggered for the entire migration. */ export type Cancel = (typeof Cancel)[keyof typeof Cancel]; export declare const CreateMode: { /** * If the operation is triggered on a non-existing server, it's equivalent to 'Create'. If the operation is triggered on an existing server, it's equivalent to 'Update'. */ readonly Default: "Default"; /** * Operation creates a new server. */ readonly Create: "Create"; /** * Operation updates an existing server. */ readonly Update: "Update"; /** * Operation restores an existing backup of an existing server. This operation creates a new server, and then restores on it the backup of an existing server at a specific point in time. */ readonly PointInTimeRestore: "PointInTimeRestore"; /** * Operation restores an existing backup of an existing server, on the paired region of the existing server. This operation creates a new server on the paired region of the existing server, and then restores on it the backup of an existing server at a specific point in time, in a different region. This operation is only supported on existing servers that were created with geographically redundant backups enabled. */ readonly GeoRestore: "GeoRestore"; /** * Operation creates a replica of an existing server. This operation creates a new server, restores a base backup of the existing server (referred to as primary), and configures physical replication to asynchronously stream all changes which are recorded in the transaction log of the primary. */ readonly Replica: "Replica"; /** * Operation creates a new server, initialized with the backup of a server that was recently deleted. */ readonly ReviveDropped: "ReviveDropped"; }; /** * Creation mode of a new server. */ export type CreateMode = (typeof CreateMode)[keyof typeof CreateMode]; export declare const DataEncryptionType: { readonly AzureKeyVault: "AzureKeyVault"; readonly SystemAssigned: "SystemAssigned"; }; export type DataEncryptionType = (typeof DataEncryptionType)[keyof typeof DataEncryptionType]; export declare const GeoRedundantBackup: { readonly Enabled: "Enabled"; readonly Disabled: "Disabled"; }; /** * Enable Geo-redundant or not for server backup. */ export type GeoRedundantBackup = (typeof GeoRedundantBackup)[keyof typeof GeoRedundantBackup]; export declare const GeographicallyRedundantBackup: { /** * Server is configured to create geographically redundant backups. */ readonly Enabled: "Enabled"; /** * Server is not configured to create geographically redundant backups. */ readonly Disabled: "Disabled"; }; /** * Indicates if the server is configured to create geographically redundant backups. */ export type GeographicallyRedundantBackup = (typeof GeographicallyRedundantBackup)[keyof typeof GeographicallyRedundantBackup]; export declare const IdentityType: { readonly UserAssigned: "UserAssigned"; readonly SystemAssigned: "SystemAssigned"; }; export type IdentityType = (typeof IdentityType)[keyof typeof IdentityType]; export declare const InfrastructureEncryption: { /** * Default value for single layer of encryption for data at rest. */ readonly Enabled: "Enabled"; /** * Additional (2nd) layer of encryption for data at rest */ readonly Disabled: "Disabled"; }; /** * Status showing whether the server enabled infrastructure encryption. */ export type InfrastructureEncryption = (typeof InfrastructureEncryption)[keyof typeof InfrastructureEncryption]; export declare const LogicalReplicationOnSourceServer: { /** * Logical replication will be set up on the source server. */ readonly True: "True"; /** * Logical replication will not be set up on the source server. */ readonly False: "False"; }; /** * Indicates whether to setup logical replication on source server, if needed. */ export type LogicalReplicationOnSourceServer = (typeof LogicalReplicationOnSourceServer)[keyof typeof LogicalReplicationOnSourceServer]; export declare const MicrosoftEntraAuth: { /** * Server supports Microsoft Entra authentication. */ readonly Enabled: "Enabled"; /** * Server does not support Microsoft Entra authentication. */ readonly Disabled: "Disabled"; }; /** * Indicates if the server supports Microsoft Entra authentication. */ export type MicrosoftEntraAuth = (typeof MicrosoftEntraAuth)[keyof typeof MicrosoftEntraAuth]; export declare const MigrateRolesAndPermissions: { /** * Roles and permissions will be migrated. */ readonly True: "True"; /** * Roles and permissions will not be migrated. */ readonly False: "False"; }; /** * Indicates if roles and permissions must be migrated. */ export type MigrateRolesAndPermissions = (typeof MigrateRolesAndPermissions)[keyof typeof MigrateRolesAndPermissions]; export declare const MigrationMode: { /** * Offline migration mode. */ readonly Offline: "Offline"; /** * Online migration mode. */ readonly Online: "Online"; }; /** * Mode used to perform the migration: Online or Offline. */ export type MigrationMode = (typeof MigrationMode)[keyof typeof MigrationMode]; export declare const MigrationOption: { /** * Validate the migration without performing it. */ readonly Validate: "Validate"; /** * Perform the migration. */ readonly Migrate: "Migrate"; /** * Validate and perform the migration. */ readonly ValidateAndMigrate: "ValidateAndMigrate"; }; /** * Supported option for a migration. */ export type MigrationOption = (typeof MigrationOption)[keyof typeof MigrationOption]; export declare const MinimalTlsVersionEnum: { readonly TLS1_0: "TLS1_0"; readonly TLS1_1: "TLS1_1"; readonly TLS1_2: "TLS1_2"; readonly TLSEnforcementDisabled: "TLSEnforcementDisabled"; }; /** * Enforce a minimal Tls version for the server. */ export type MinimalTlsVersionEnum = (typeof MinimalTlsVersionEnum)[keyof typeof MinimalTlsVersionEnum]; export declare const OverwriteDatabasesOnTargetServer: { /** * Databases on the target server can be overwritten when already present. */ readonly True: "True"; /** * Databases on the target server cannot be overwritten when already present. When the migration workflow detects that the database already exists on the target server, it will wait for a confirmation. */ readonly False: "False"; }; /** * Indicates if databases on the target server can be overwritten when already present. If set to 'False', when the migration workflow detects that the database already exists on the target server, it will wait for a confirmation. */ export type OverwriteDatabasesOnTargetServer = (typeof OverwriteDatabasesOnTargetServer)[keyof typeof OverwriteDatabasesOnTargetServer]; export declare const PasswordAuth: { readonly Enabled: "enabled"; readonly Disabled: "disabled"; }; export type PasswordAuth = (typeof PasswordAuth)[keyof typeof PasswordAuth]; export declare const PasswordBasedAuth: { /** * Server supports password based authentication. */ readonly Enabled: "Enabled"; /** * Server does not support password based authentication. */ readonly Disabled: "Disabled"; }; /** * Indicates if the server supports password based authentication. */ export type PasswordBasedAuth = (typeof PasswordBasedAuth)[keyof typeof PasswordBasedAuth]; export declare const PostgreSqlFlexibleServerHighAvailabilityMode: { /** * High availability is disabled for the server. */ readonly Disabled: "Disabled"; /** * High availability is enabled for the server, with standby server in a different availability zone than that of the primary. */ readonly ZoneRedundant: "ZoneRedundant"; /** * High availability is enabled for the server, with standby server in the same availability zone as the primary. */ readonly SameZone: "SameZone"; }; /** * High availability mode for a server. */ export type PostgreSqlFlexibleServerHighAvailabilityMode = (typeof PostgreSqlFlexibleServerHighAvailabilityMode)[keyof typeof PostgreSqlFlexibleServerHighAvailabilityMode]; export declare const PostgresMajorVersion: { /** * PostgreSQL 18. */ readonly PostgresMajorVersion_18: "18"; /** * PostgreSQL 17. */ readonly PostgresMajorVersion_17: "17"; /** * PostgreSQL 16. */ readonly PostgresMajorVersion_16: "16"; /** * PostgreSQL 15. */ readonly PostgresMajorVersion_15: "15"; /** * PostgreSQL 14. */ readonly PostgresMajorVersion_14: "14"; /** * PostgreSQL 13. */ readonly PostgresMajorVersion_13: "13"; /** * PostgreSQL 12. */ readonly PostgresMajorVersion_12: "12"; /** * PostgreSQL 11. */ readonly PostgresMajorVersion_11: "11"; }; /** * Major version of PostgreSQL database engine. */ export type PostgresMajorVersion = (typeof PostgresMajorVersion)[keyof typeof PostgresMajorVersion]; export declare const PrincipalType: { readonly User: "user"; readonly ServicePrincipal: "servicePrincipal"; readonly Group: "group"; }; export type PrincipalType = (typeof PrincipalType)[keyof typeof PrincipalType]; export declare const PrivateEndpointServiceConnectionStatus: { readonly Pending: "Pending"; readonly Approved: "Approved"; readonly Rejected: "Rejected"; }; /** * Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service. */ export type PrivateEndpointServiceConnectionStatus = (typeof PrivateEndpointServiceConnectionStatus)[keyof typeof PrivateEndpointServiceConnectionStatus]; export declare const PublicNetworkAccessEnum: { readonly Enabled: "Enabled"; readonly Disabled: "Disabled"; }; /** * Whether or not public network access is allowed for this server. Value is optional but if passed in, must be 'Enabled' or 'Disabled' */ export type PublicNetworkAccessEnum = (typeof PublicNetworkAccessEnum)[keyof typeof PublicNetworkAccessEnum]; export declare const ReadReplicaPromoteMode: { /** * Read replica will become an independent server, and a completely independent entity from the replication set. */ readonly Standalone: "Standalone"; /** * Read replica will swap roles with primary server. */ readonly Switchover: "Switchover"; }; /** * Type of operation to apply on the read replica. This property is write only. Standalone means that the read replica will be promoted to a standalone server, and will become a completely independent entity from the replication set. Switchover means that the read replica will roles with the primary server. */ export type ReadReplicaPromoteMode = (typeof ReadReplicaPromoteMode)[keyof typeof ReadReplicaPromoteMode]; export declare const ReadReplicaPromoteOption: { /** * Wait for data in the read replica to be fully synchronized with its source server before it initiates the operation. */ readonly Planned: "Planned"; /** * Initiate the operation immediately, without waiting for data in the read replica to be synchronized with its source server. */ readonly Forced: "Forced"; }; /** * Data synchronization option to use when processing the operation specified in the promoteMode property. This property is write only. */ export type ReadReplicaPromoteOption = (typeof ReadReplicaPromoteOption)[keyof typeof ReadReplicaPromoteOption]; export declare const ReplicationRole: { /** * No replication role assigned; the server operates independently. */ readonly None: "None"; /** * Acts as the source server for replication to one or more replicas. */ readonly Primary: "Primary"; /** * Receives data asynchronously from a primary server within the same region. */ readonly AsyncReplica: "AsyncReplica"; /** * Receives data asynchronously from a primary server in a different region for geographical redundancy. */ readonly GeoAsyncReplica: "GeoAsyncReplica"; }; /** * Role of the server in a replication set. */ export type ReplicationRole = (typeof ReplicationRole)[keyof typeof ReplicationRole]; export declare const RoleType: { readonly User: "user"; readonly Admin: "admin"; }; export type RoleType = (typeof RoleType)[keyof typeof RoleType]; export declare const ServerPublicNetworkAccessState: { /** * Public network access is enabled. This allows the server to be accessed from the public internet, provided the necessary firewall rule that allows incoming traffic originating from the connecting client is in place. This is compatible with the use of private endpoints to connect to this server. */ readonly Enabled: "Enabled"; /** * Public network access is disabled. This means the server cannot be accessed from the public internet, but only via private endpoints. */ readonly Disabled: "Disabled"; }; /** * Indicates if public network access is enabled or not. This is only supported for servers that are not integrated into a virtual network which is owned and provided by customer when server is deployed. */ export type ServerPublicNetworkAccessState = (typeof ServerPublicNetworkAccessState)[keyof typeof ServerPublicNetworkAccessState]; export declare const ServerSecurityAlertPolicyState: { readonly Enabled: "Enabled"; readonly Disabled: "Disabled"; }; /** * Specifies the state of the policy, whether it is enabled or disabled. */ export type ServerSecurityAlertPolicyState = (typeof ServerSecurityAlertPolicyState)[keyof typeof ServerSecurityAlertPolicyState]; export declare const SingleServerCreateMode: { readonly Default: "Default"; readonly PointInTimeRestore: "PointInTimeRestore"; readonly GeoRestore: "GeoRestore"; readonly Replica: "Replica"; }; /** * The mode to create a new server. */ export type SingleServerCreateMode = (typeof SingleServerCreateMode)[keyof typeof SingleServerCreateMode]; export declare const SingleServerIdentityProperties: { readonly SystemAssigned: "SystemAssigned"; }; /** * The identity type. Set this to 'SystemAssigned' in order to automatically create and assign an Azure Active Directory principal for the resource. */ export type SingleServerIdentityProperties = (typeof SingleServerIdentityProperties)[keyof typeof SingleServerIdentityProperties]; export declare const SingleServerSkuTier: { readonly Basic: "Basic"; readonly GeneralPurpose: "GeneralPurpose"; readonly MemoryOptimized: "MemoryOptimized"; }; /** * The tier of the particular SKU, e.g. Basic. */ export type SingleServerSkuTier = (typeof SingleServerSkuTier)[keyof typeof SingleServerSkuTier]; export declare const SingleServerVersion: { readonly SingleServerVersion_9_5: "9.5"; readonly SingleServerVersion_9_6: "9.6"; readonly SingleServerVersion_10: "10"; readonly SingleServerVersion_10_0: "10.0"; readonly SingleServerVersion_10_2: "10.2"; readonly SingleServerVersion_11: "11"; }; /** * Server version. */ export type SingleServerVersion = (typeof SingleServerVersion)[keyof typeof SingleServerVersion]; export declare const SkuTier: { /** * Cost-effective tier for infrequent CPU usage, ideal for development and testing workloads with low performance requirements. */ readonly Burstable: "Burstable"; /** * Balanced compute and memory for most workloads, offering scalable performance and I/O throughput. */ readonly GeneralPurpose: "GeneralPurpose"; /** * High memory-to-core ratio for demanding workloads needing fast in-memory processing and high concurrency. */ readonly MemoryOptimized: "MemoryOptimized"; }; /** * Tier of the compute assigned to a server. */ export type SkuTier = (typeof SkuTier)[keyof typeof SkuTier]; export declare const SourceType: { /** * On-premises PostgreSQL server. */ readonly OnPremises: "OnPremises"; /** * Amazon Web Services PostgreSQL server. */ readonly AWS: "AWS"; /** * Google Cloud Platform PostgreSQL server. */ readonly GCP: "GCP"; /** * Azure Virtual Machine PostgreSQL server. */ readonly AzureVM: "AzureVM"; /** * Azure Database for PostgreSQL single server. */ readonly PostgreSQLSingleServer: "PostgreSQLSingleServer"; /** * Amazon RDS for PostgreSQL. */ readonly AWS_RDS: "AWS_RDS"; /** * Amazon Aurora for PostgreSQL. */ readonly AWS_AURORA: "AWS_AURORA"; /** * Amazon EC2 for PostgreSQL. */ readonly AWS_EC2: "AWS_EC2"; /** * Google Cloud SQL for PostgreSQL. */ readonly GCP_CloudSQL: "GCP_CloudSQL"; /** * Google Cloud AlloyDB for PostgreSQL. */ readonly GCP_AlloyDB: "GCP_AlloyDB"; /** * Google Compute Engine for PostgreSQL. */ readonly GCP_Compute: "GCP_Compute"; /** * EnterpriseDB PostgreSQL server. */ readonly EDB: "EDB"; /** * EnterpriseDB Oracle Server. */ readonly EDB_Oracle_Server: "EDB_Oracle_Server"; /** * EnterpriseDB PostgreSQL server. */ readonly EDB_PostgreSQL: "EDB_PostgreSQL"; /** * Azure Database for PostgreSQL flexible server. */ readonly PostgreSQLFlexibleServer: "PostgreSQLFlexibleServer"; /** * .NET Cosmos DB for PostgreSQL */ readonly PostgreSQLCosmosDB: "PostgreSQLCosmosDB"; /** * Huawei RDS for PostgreSQL */ readonly Huawei_RDS: "Huawei_RDS"; /** * Huawei Compute for PostgreSQL */ readonly Huawei_Compute: "Huawei_Compute"; /** * Heroku PostgreSQL */ readonly Heroku_PostgreSQL: "Heroku_PostgreSQL"; /** * Crunchy PostgreSQL */ readonly Crunchy_PostgreSQL: "Crunchy_PostgreSQL"; /** * ApsaraDB RDS for PostgreSQL */ readonly ApsaraDB_RDS: "ApsaraDB_RDS"; /** * Digital Ocean Droplets for PostgreSQL */ readonly Digital_Ocean_Droplets: "Digital_Ocean_Droplets"; /** * Digital Ocean PostgreSQL */ readonly Digital_Ocean_PostgreSQL: "Digital_Ocean_PostgreSQL"; /** * Supabase PostgreSQL */ readonly Supabase_PostgreSQL: "Supabase_PostgreSQL"; }; /** * Source server type used for the migration: ApsaraDB_RDS, AWS, AWS_AURORA, AWS_EC2, AWS_RDS, AzureVM, Crunchy_PostgreSQL, Digital_Ocean_Droplets, Digital_Ocean_PostgreSQL, EDB, EDB_Oracle_Server, EDB_PostgreSQL, GCP, GCP_AlloyDB, GCP_CloudSQL, GCP_Compute, Heroku_PostgreSQL, Huawei_Compute, Huawei_RDS, OnPremises, PostgreSQLCosmosDB, PostgreSQLFlexibleServer, PostgreSQLSingleServer, or Supabase_PostgreSQL */ export type SourceType = (typeof SourceType)[keyof typeof SourceType]; export declare const SslEnforcementEnum: { readonly Enabled: "Enabled"; readonly Disabled: "Disabled"; }; /** * Enable ssl enforcement or not when connect to server. */ export type SslEnforcementEnum = (typeof SslEnforcementEnum)[keyof typeof SslEnforcementEnum]; export declare const SslMode: { /** * Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL. */ readonly Prefer: "Prefer"; /** * Require SSL connection. If the server does not support SSL, the connection will fail. */ readonly Require: "Require"; /** * Require SSL connection and verify the server certificate against the CA certificate. */ readonly VerifyCA: "VerifyCA"; /** * Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate. */ readonly VerifyFull: "VerifyFull"; }; /** * SSL mode used by a migration. Default SSL mode for 'PostgreSQLSingleServer' is 'VerifyFull'. Default SSL mode for other source types is 'Prefer'. */ export type SslMode = (typeof SslMode)[keyof typeof SslMode]; export declare const StartDataMigration: { /** * Data migration must start right away. */ readonly True: "True"; /** * Data migration must not start right away. */ readonly False: "False"; }; /** * Indicates if data migration must start right away. */ export type StartDataMigration = (typeof StartDataMigration)[keyof typeof StartDataMigration]; export declare const StorageAutoGrow: { /** * Server should automatically grow storage size when available space is nearing zero and conditions allow for automatically growing storage size. */ readonly Enabled: "Enabled"; /** * Server should not automatically grow storage size when available space is nearing zero. */ readonly Disabled: "Disabled"; }; /** * Flag to enable or disable the automatic growth of storage size of a server when available space is nearing zero and conditions allow for automatically growing storage size. */ export type StorageAutoGrow = (typeof StorageAutoGrow)[keyof typeof StorageAutoGrow]; export declare const StorageAutogrow: { readonly Enabled: "Enabled"; readonly Disabled: "Disabled"; }; /** * Enable Storage Auto Grow. */ export type StorageAutogrow = (typeof StorageAutogrow)[keyof typeof StorageAutogrow]; export declare const StorageType: { /** * Standard Solid State Disk (SSD) backed storage offering consistent performance for general purpose workloads. */ readonly Premium_LRS: "Premium_LRS"; /** * Next generation Solid State Disk (SSD) storage with improved scalability and performance for demanding enterprise workloads. */ readonly PremiumV2_LRS: "PremiumV2_LRS"; /** * High-end Solid State Disk (SSD) storage designed for extreme IOPS and latency-sensitive applications. */ readonly UltraSSD_LRS: "UltraSSD_LRS"; }; /** * Type of storage assigned to a server. Allowed values are Premium_LRS, PremiumV2_LRS, or UltraSSD_LRS. If not specified, it defaults to Premium_LRS. */ export type StorageType = (typeof StorageType)[keyof typeof StorageType]; export declare const TriggerCutover: { /** * Cutover must be triggered for the entire migration. */ readonly True: "True"; /** * Cutover must not be triggered for the entire migration. */ readonly False: "False"; }; /** * Indicates if cutover must be triggered for the entire migration. */ export type TriggerCutover = (typeof TriggerCutover)[keyof typeof TriggerCutover]; export declare const VirtualEndpointType: { /** * Read-write endpoint. */ readonly ReadWrite: "ReadWrite"; }; /** * Type of endpoint for the virtual endpoints. */ export type VirtualEndpointType = (typeof VirtualEndpointType)[keyof typeof VirtualEndpointType]; //# sourceMappingURL=index.d.ts.map