pulumi-azure-native 2.71.0__py3-none-any.whl → 2.71.0a1730993707__py3-none-any.whl

pulumi_azure_native/__init__.py

@@ -16165,20 +16165,6 @@ _utilities.register(
    "azure-native:recoveryservices/v20240730preview:ResourceGuardProxy": "ResourceGuardProxy"
   }
  },
- {
-  "pkg": "azure-native",
-  "mod": "recoveryservices/v20241001",
-  "fqn": "pulumi_azure_native.recoveryservices.v20241001",
-  "classes": {
-   "azure-native:recoveryservices/v20241001:PrivateEndpointConnection": "PrivateEndpointConnection",
-   "azure-native:recoveryservices/v20241001:ProtectedItem": "ProtectedItem",
-   "azure-native:recoveryservices/v20241001:ProtectionContainer": "ProtectionContainer",
-   "azure-native:recoveryservices/v20241001:ProtectionIntent": "ProtectionIntent",
-   "azure-native:recoveryservices/v20241001:ProtectionPolicy": "ProtectionPolicy",
-   "azure-native:recoveryservices/v20241001:ResourceGuardProxy": "ResourceGuardProxy",
-   "azure-native:recoveryservices/v20241001:Vault": "Vault"
-  }
- },
  {
   "pkg": "azure-native",
   "mod": "redhatopenshift",

pulumi_azure_native/datafactory/_inputs.py

@@ -19592,10 +19592,6 @@ if not MYPY:
         """
         List of tags that can be used for describing the linked service.
         """
-        command_timeout: NotRequired[Any]
-        """
-        The time to wait (in seconds) while trying to execute a command before terminating the attempt and generating an error. Set to zero for infinity. Type: integer.
-        """
         connect_via: NotRequired[pulumi.Input['IntegrationRuntimeReferenceArgsDict']]
         """
         The integration runtime reference.
@@ -19604,18 +19600,10 @@ if not MYPY:
         """
         An ODBC connection string. Type: string, SecureString or AzureKeyVaultSecretReference.
         """
-        database: NotRequired[Any]
-        """
-        Database name for connection. Type: string.
-        """
         description: NotRequired[pulumi.Input[str]]
         """
         Linked service description.
         """
-        encoding: NotRequired[Any]
-        """
-        Gets or sets the .NET encoding that will be used to encode/decode PostgreSQL string data. Type: string
-        """
         encrypted_credential: NotRequired[pulumi.Input[str]]
         """
         The encrypted credential used for authentication. Credentials are encrypted using the integration runtime credential manager. Type: string.
@@ -19628,38 +19616,6 @@ if not MYPY:
         """
         The Azure key vault secret reference of password in connection string.
         """
-        port: NotRequired[Any]
-        """
-        The port for the connection. Type: integer.
-        """
-        read_buffer_size: NotRequired[Any]
-        """
-        Determines the size of the internal buffer uses when reading. Increasing may improve performance if transferring large values from the database. Type: integer.
-        """
-        server: NotRequired[Any]
-        """
-        Server name for connection. Type: string.
-        """
-        ssl_mode: NotRequired[Any]
-        """
-        SSL mode for connection. Type: integer. 0: disable, 1:allow, 2: prefer, 3: require, 4: verify-ca, 5: verify-full. Type: integer.
-        """
-        timeout: NotRequired[Any]
-        """
-        The time to wait (in seconds) while trying to establish a connection before terminating the attempt and generating an error. Type: integer.
-        """
-        timezone: NotRequired[Any]
-        """
-        Gets or sets the session timezone. Type: string.
-        """
-        trust_server_certificate: NotRequired[Any]
-        """
-        Whether to trust the server certificate without validating it. Type: boolean.
-        """
-        username: NotRequired[Any]
-        """
-        Username for authentication. Type: string.
-        """
         version: NotRequired[pulumi.Input[str]]
         """
         Version of the linked service.
@@ -19672,85 +19628,41 @@ class AzurePostgreSqlLinkedServiceArgs:
     def __init__(__self__, *,
                  type: pulumi.Input[str],
                  annotations: Optional[pulumi.Input[Sequence[Any]]] = None,
-                 command_timeout: Optional[Any] = None,
                  connect_via: Optional[pulumi.Input['IntegrationRuntimeReferenceArgs']] = None,
                  connection_string: Optional[Any] = None,
-                 database: Optional[Any] = None,
                  description: Optional[pulumi.Input[str]] = None,
-                 encoding: Optional[Any] = None,
                  encrypted_credential: Optional[pulumi.Input[str]] = None,
                  parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input['ParameterSpecificationArgs']]]] = None,
                  password: Optional[pulumi.Input['AzureKeyVaultSecretReferenceArgs']] = None,
-                 port: Optional[Any] = None,
-                 read_buffer_size: Optional[Any] = None,
-                 server: Optional[Any] = None,
-                 ssl_mode: Optional[Any] = None,
-                 timeout: Optional[Any] = None,
-                 timezone: Optional[Any] = None,
-                 trust_server_certificate: Optional[Any] = None,
-                 username: Optional[Any] = None,
                  version: Optional[pulumi.Input[str]] = None):
         """
         Azure PostgreSQL linked service.
         :param pulumi.Input[str] type: Type of linked service.
                Expected value is 'AzurePostgreSql'.
         :param pulumi.Input[Sequence[Any]] annotations: List of tags that can be used for describing the linked service.
-        :param Any command_timeout: The time to wait (in seconds) while trying to execute a command before terminating the attempt and generating an error. Set to zero for infinity. Type: integer.
         :param pulumi.Input['IntegrationRuntimeReferenceArgs'] connect_via: The integration runtime reference.
         :param Any connection_string: An ODBC connection string. Type: string, SecureString or AzureKeyVaultSecretReference.
-        :param Any database: Database name for connection. Type: string.
         :param pulumi.Input[str] description: Linked service description.
-        :param Any encoding: Gets or sets the .NET encoding that will be used to encode/decode PostgreSQL string data. Type: string
         :param pulumi.Input[str] encrypted_credential: The encrypted credential used for authentication. Credentials are encrypted using the integration runtime credential manager. Type: string.
         :param pulumi.Input[Mapping[str, pulumi.Input['ParameterSpecificationArgs']]] parameters: Parameters for linked service.
         :param pulumi.Input['AzureKeyVaultSecretReferenceArgs'] password: The Azure key vault secret reference of password in connection string.
-        :param Any port: The port for the connection. Type: integer.
-        :param Any read_buffer_size: Determines the size of the internal buffer uses when reading. Increasing may improve performance if transferring large values from the database. Type: integer.
-        :param Any server: Server name for connection. Type: string.
-        :param Any ssl_mode: SSL mode for connection. Type: integer. 0: disable, 1:allow, 2: prefer, 3: require, 4: verify-ca, 5: verify-full. Type: integer.
-        :param Any timeout: The time to wait (in seconds) while trying to establish a connection before terminating the attempt and generating an error. Type: integer.
-        :param Any timezone: Gets or sets the session timezone. Type: string.
-        :param Any trust_server_certificate: Whether to trust the server certificate without validating it. Type: boolean.
-        :param Any username: Username for authentication. Type: string.
         :param pulumi.Input[str] version: Version of the linked service.
         """
         pulumi.set(__self__, "type", 'AzurePostgreSql')
         if annotations is not None:
             pulumi.set(__self__, "annotations", annotations)
-        if command_timeout is not None:
-            pulumi.set(__self__, "command_timeout", command_timeout)
         if connect_via is not None:
             pulumi.set(__self__, "connect_via", connect_via)
         if connection_string is not None:
             pulumi.set(__self__, "connection_string", connection_string)
-        if database is not None:
-            pulumi.set(__self__, "database", database)
         if description is not None:
             pulumi.set(__self__, "description", description)
-        if encoding is not None:
-            pulumi.set(__self__, "encoding", encoding)
         if encrypted_credential is not None:
             pulumi.set(__self__, "encrypted_credential", encrypted_credential)
         if parameters is not None:
             pulumi.set(__self__, "parameters", parameters)
         if password is not None:
             pulumi.set(__self__, "password", password)
-        if port is not None:
-            pulumi.set(__self__, "port", port)
-        if read_buffer_size is not None:
-            pulumi.set(__self__, "read_buffer_size", read_buffer_size)
-        if server is not None:
-            pulumi.set(__self__, "server", server)
-        if ssl_mode is not None:
-            pulumi.set(__self__, "ssl_mode", ssl_mode)
-        if timeout is not None:
-            pulumi.set(__self__, "timeout", timeout)
-        if timezone is not None:
-            pulumi.set(__self__, "timezone", timezone)
-        if trust_server_certificate is not None:
-            pulumi.set(__self__, "trust_server_certificate", trust_server_certificate)
-        if username is not None:
-            pulumi.set(__self__, "username", username)
         if version is not None:
             pulumi.set(__self__, "version", version)
 
@@ -19779,18 +19691,6 @@ class AzurePostgreSqlLinkedServiceArgs:
     def annotations(self, value: Optional[pulumi.Input[Sequence[Any]]]):
         pulumi.set(self, "annotations", value)
 
-    @property
-    @pulumi.getter(name="commandTimeout")
-    def command_timeout(self) -> Optional[Any]:
-        """
-        The time to wait (in seconds) while trying to execute a command before terminating the attempt and generating an error. Set to zero for infinity. Type: integer.
-        """
-        return pulumi.get(self, "command_timeout")
-
-    @command_timeout.setter
-    def command_timeout(self, value: Optional[Any]):
-        pulumi.set(self, "command_timeout", value)
-
     @property
     @pulumi.getter(name="connectVia")
     def connect_via(self) -> Optional[pulumi.Input['IntegrationRuntimeReferenceArgs']]:
@@ -19815,18 +19715,6 @@ class AzurePostgreSqlLinkedServiceArgs:
     def connection_string(self, value: Optional[Any]):
         pulumi.set(self, "connection_string", value)
 
-    @property
-    @pulumi.getter
-    def database(self) -> Optional[Any]:
-        """
-        Database name for connection. Type: string.
-        """
-        return pulumi.get(self, "database")
-
-    @database.setter
-    def database(self, value: Optional[Any]):
-        pulumi.set(self, "database", value)
-
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -19839,18 +19727,6 @@ class AzurePostgreSqlLinkedServiceArgs:
     def description(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "description", value)
 
-    @property
-    @pulumi.getter
-    def encoding(self) -> Optional[Any]:
-        """
-        Gets or sets the .NET encoding that will be used to encode/decode PostgreSQL string data. Type: string
-        """
-        return pulumi.get(self, "encoding")
-
-    @encoding.setter
-    def encoding(self, value: Optional[Any]):
-        pulumi.set(self, "encoding", value)
-
     @property
     @pulumi.getter(name="encryptedCredential")
     def encrypted_credential(self) -> Optional[pulumi.Input[str]]:
@@ -19887,102 +19763,6 @@ class AzurePostgreSqlLinkedServiceArgs:
     def password(self, value: Optional[pulumi.Input['AzureKeyVaultSecretReferenceArgs']]):
         pulumi.set(self, "password", value)
 
-    @property
-    @pulumi.getter
-    def port(self) -> Optional[Any]:
-        """
-        The port for the connection. Type: integer.
-        """
-        return pulumi.get(self, "port")
-
-    @port.setter
-    def port(self, value: Optional[Any]):
-        pulumi.set(self, "port", value)
-
-    @property
-    @pulumi.getter(name="readBufferSize")
-    def read_buffer_size(self) -> Optional[Any]:
-        """
-        Determines the size of the internal buffer uses when reading. Increasing may improve performance if transferring large values from the database. Type: integer.
-        """
-        return pulumi.get(self, "read_buffer_size")
-
-    @read_buffer_size.setter
-    def read_buffer_size(self, value: Optional[Any]):
-        pulumi.set(self, "read_buffer_size", value)
-
-    @property
-    @pulumi.getter
-    def server(self) -> Optional[Any]:
-        """
-        Server name for connection. Type: string.
-        """
-        return pulumi.get(self, "server")
-
-    @server.setter
-    def server(self, value: Optional[Any]):
-        pulumi.set(self, "server", value)
-
-    @property
-    @pulumi.getter(name="sslMode")
-    def ssl_mode(self) -> Optional[Any]:
-        """
-        SSL mode for connection. Type: integer. 0: disable, 1:allow, 2: prefer, 3: require, 4: verify-ca, 5: verify-full. Type: integer.
-        """
-        return pulumi.get(self, "ssl_mode")
-
-    @ssl_mode.setter
-    def ssl_mode(self, value: Optional[Any]):
-        pulumi.set(self, "ssl_mode", value)
-
-    @property
-    @pulumi.getter
-    def timeout(self) -> Optional[Any]:
-        """
-        The time to wait (in seconds) while trying to establish a connection before terminating the attempt and generating an error. Type: integer.
-        """
-        return pulumi.get(self, "timeout")
-
-    @timeout.setter
-    def timeout(self, value: Optional[Any]):
-        pulumi.set(self, "timeout", value)
-
-    @property
-    @pulumi.getter
-    def timezone(self) -> Optional[Any]:
-        """
-        Gets or sets the session timezone. Type: string.
-        """
-        return pulumi.get(self, "timezone")
-
-    @timezone.setter
-    def timezone(self, value: Optional[Any]):
-        pulumi.set(self, "timezone", value)
-
-    @property
-    @pulumi.getter(name="trustServerCertificate")
-    def trust_server_certificate(self) -> Optional[Any]:
-        """
-        Whether to trust the server certificate without validating it. Type: boolean.
-        """
-        return pulumi.get(self, "trust_server_certificate")
-
-    @trust_server_certificate.setter
-    def trust_server_certificate(self, value: Optional[Any]):
-        pulumi.set(self, "trust_server_certificate", value)
-
-    @property
-    @pulumi.getter
-    def username(self) -> Optional[Any]:
-        """
-        Username for authentication. Type: string.
-        """
-        return pulumi.get(self, "username")
-
-    @username.setter
-    def username(self, value: Optional[Any]):
-        pulumi.set(self, "username", value)
-
     @property
     @pulumi.getter
     def version(self) -> Optional[pulumi.Input[str]]:
@@ -73639,10 +73419,6 @@ if not MYPY:
         Type of linked service.
         Expected value is 'MySql'.
         """
-        allow_zero_date_time: NotRequired[Any]
-        """
-        This allows the special “zero” date value 0000-00-00 to be retrieved from the database. Type: boolean.
-        """
         annotations: NotRequired[pulumi.Input[Sequence[Any]]]
         """
         List of tags that can be used for describing the linked service.
@@ -73655,14 +73431,6 @@ if not MYPY:
         """
         The connection string. Type: string, SecureString or AzureKeyVaultSecretReference.
         """
-        connection_timeout: NotRequired[Any]
-        """
-        The length of time (in seconds) to wait for a connection to the server before terminating the attempt and generating an error. Type: integer.
-        """
-        convert_zero_date_time: NotRequired[Any]
-        """
-        True to return DateTime.MinValue for date or datetime columns that have disallowed values. Type: boolean.
-        """
         database: NotRequired[Any]
         """
         Database name for connection. Type: string.
@@ -73679,10 +73447,6 @@ if not MYPY:
         """
         The encrypted credential used for authentication. Credentials are encrypted using the integration runtime credential manager. Type: string.
         """
-        guid_format: NotRequired[Any]
-        """
-        Determines which column type (if any) should be read as a GUID. Type: string. None: No column types are automatically read as a Guid; Char36: All CHAR(36) columns are read/written as a Guid using lowercase hex with hyphens, which matches UUID.
-        """
         parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['ParameterSpecificationArgsDict']]]]
         """
         Parameters for linked service.
@@ -73699,22 +73463,10 @@ if not MYPY:
         """
         Server name for connection. Type: string.
         """
-        ssl_cert: NotRequired[Any]
-        """
-        The path to the client’s SSL certificate file in PEM format. SslKey must also be specified. Type: string.
-        """
-        ssl_key: NotRequired[Any]
-        """
-        The path to the client’s SSL private key in PEM format. SslCert must also be specified. Type: string.
-        """
         ssl_mode: NotRequired[Any]
         """
         SSL mode for connection. Type: integer. 0: disable, 1: prefer, 2: require, 3: verify-ca, 4: verify-full.
         """
-        treat_tiny_as_boolean: NotRequired[Any]
-        """
-        When set to true, TINYINT(1) values are returned as booleans. Type: bool.
-        """
         use_system_trust_store: NotRequired[Any]
         """
         Use system trust store for connection. Type: integer. 0: enable, 1: disable.
@@ -73734,25 +73486,18 @@ elif False:
 class MySqlLinkedServiceArgs:
     def __init__(__self__, *,
                  type: pulumi.Input[str],
-                 allow_zero_date_time: Optional[Any] = None,
                  annotations: Optional[pulumi.Input[Sequence[Any]]] = None,
                  connect_via: Optional[pulumi.Input['IntegrationRuntimeReferenceArgs']] = None,
                  connection_string: Optional[Any] = None,
-                 connection_timeout: Optional[Any] = None,
-                 convert_zero_date_time: Optional[Any] = None,
                  database: Optional[Any] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  driver_version: Optional[Any] = None,
                  encrypted_credential: Optional[pulumi.Input[str]] = None,
-                 guid_format: Optional[Any] = None,
                  parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input['ParameterSpecificationArgs']]]] = None,
                  password: Optional[pulumi.Input['AzureKeyVaultSecretReferenceArgs']] = None,
                  port: Optional[Any] = None,
                  server: Optional[Any] = None,
-                 ssl_cert: Optional[Any] = None,
-                 ssl_key: Optional[Any] = None,
                  ssl_mode: Optional[Any] = None,
-                 treat_tiny_as_boolean: Optional[Any] = None,
                  use_system_trust_store: Optional[Any] = None,
                  username: Optional[Any] = None,
                  version: Optional[pulumi.Input[str]] = None):
@@ -73760,42 +73505,29 @@ class MySqlLinkedServiceArgs:
         Linked service for MySQL data source.
         :param pulumi.Input[str] type: Type of linked service.
                Expected value is 'MySql'.
-        :param Any allow_zero_date_time: This allows the special “zero” date value 0000-00-00 to be retrieved from the database. Type: boolean.
         :param pulumi.Input[Sequence[Any]] annotations: List of tags that can be used for describing the linked service.
         :param pulumi.Input['IntegrationRuntimeReferenceArgs'] connect_via: The integration runtime reference.
         :param Any connection_string: The connection string. Type: string, SecureString or AzureKeyVaultSecretReference.
-        :param Any connection_timeout: The length of time (in seconds) to wait for a connection to the server before terminating the attempt and generating an error. Type: integer.
-        :param Any convert_zero_date_time: True to return DateTime.MinValue for date or datetime columns that have disallowed values. Type: boolean.
         :param Any database: Database name for connection. Type: string.
         :param pulumi.Input[str] description: Linked service description.
         :param Any driver_version: The version of the MySQL driver. Type: string. V1 or empty for legacy driver, V2 for new driver. V1 can support connection string and property bag, V2 can only support connection string.
         :param pulumi.Input[str] encrypted_credential: The encrypted credential used for authentication. Credentials are encrypted using the integration runtime credential manager. Type: string.
-        :param Any guid_format: Determines which column type (if any) should be read as a GUID. Type: string. None: No column types are automatically read as a Guid; Char36: All CHAR(36) columns are read/written as a Guid using lowercase hex with hyphens, which matches UUID.
         :param pulumi.Input[Mapping[str, pulumi.Input['ParameterSpecificationArgs']]] parameters: Parameters for linked service.
         :param pulumi.Input['AzureKeyVaultSecretReferenceArgs'] password: The Azure key vault secret reference of password in connection string.
         :param Any port: The port for the connection. Type: integer.
         :param Any server: Server name for connection. Type: string.
-        :param Any ssl_cert: The path to the client’s SSL certificate file in PEM format. SslKey must also be specified. Type: string.
-        :param Any ssl_key: The path to the client’s SSL private key in PEM format. SslCert must also be specified. Type: string.
         :param Any ssl_mode: SSL mode for connection. Type: integer. 0: disable, 1: prefer, 2: require, 3: verify-ca, 4: verify-full.
-        :param Any treat_tiny_as_boolean: When set to true, TINYINT(1) values are returned as booleans. Type: bool.
         :param Any use_system_trust_store: Use system trust store for connection. Type: integer. 0: enable, 1: disable.
         :param Any username: Username for authentication. Type: string.
         :param pulumi.Input[str] version: Version of the linked service.
         """
         pulumi.set(__self__, "type", 'MySql')
-        if allow_zero_date_time is not None:
-            pulumi.set(__self__, "allow_zero_date_time", allow_zero_date_time)
         if annotations is not None:
             pulumi.set(__self__, "annotations", annotations)
         if connect_via is not None:
             pulumi.set(__self__, "connect_via", connect_via)
         if connection_string is not None:
             pulumi.set(__self__, "connection_string", connection_string)
-        if connection_timeout is not None:
-            pulumi.set(__self__, "connection_timeout", connection_timeout)
-        if convert_zero_date_time is not None:
-            pulumi.set(__self__, "convert_zero_date_time", convert_zero_date_time)
         if database is not None:
             pulumi.set(__self__, "database", database)
         if description is not None:
@@ -73804,8 +73536,6 @@ class MySqlLinkedServiceArgs:
             pulumi.set(__self__, "driver_version", driver_version)
         if encrypted_credential is not None:
             pulumi.set(__self__, "encrypted_credential", encrypted_credential)
-        if guid_format is not None:
-            pulumi.set(__self__, "guid_format", guid_format)
         if parameters is not None:
             pulumi.set(__self__, "parameters", parameters)
         if password is not None:
@@ -73814,14 +73544,8 @@ class MySqlLinkedServiceArgs:
             pulumi.set(__self__, "port", port)
         if server is not None:
             pulumi.set(__self__, "server", server)
-        if ssl_cert is not None:
-            pulumi.set(__self__, "ssl_cert", ssl_cert)
-        if ssl_key is not None:
-            pulumi.set(__self__, "ssl_key", ssl_key)
         if ssl_mode is not None:
             pulumi.set(__self__, "ssl_mode", ssl_mode)
-        if treat_tiny_as_boolean is not None:
-            pulumi.set(__self__, "treat_tiny_as_boolean", treat_tiny_as_boolean)
         if use_system_trust_store is not None:
             pulumi.set(__self__, "use_system_trust_store", use_system_trust_store)
         if username is not None:
@@ -73842,18 +73566,6 @@ class MySqlLinkedServiceArgs:
     def type(self, value: pulumi.Input[str]):
         pulumi.set(self, "type", value)
 
-    @property
-    @pulumi.getter(name="allowZeroDateTime")
-    def allow_zero_date_time(self) -> Optional[Any]:
-        """
-        This allows the special “zero” date value 0000-00-00 to be retrieved from the database. Type: boolean.
-        """
-        return pulumi.get(self, "allow_zero_date_time")
-
-    @allow_zero_date_time.setter
-    def allow_zero_date_time(self, value: Optional[Any]):
-        pulumi.set(self, "allow_zero_date_time", value)
-
     @property
     @pulumi.getter
     def annotations(self) -> Optional[pulumi.Input[Sequence[Any]]]:
@@ -73890,30 +73602,6 @@ class MySqlLinkedServiceArgs:
     def connection_string(self, value: Optional[Any]):
         pulumi.set(self, "connection_string", value)
 
-    @property
-    @pulumi.getter(name="connectionTimeout")
-    def connection_timeout(self) -> Optional[Any]:
-        """
-        The length of time (in seconds) to wait for a connection to the server before terminating the attempt and generating an error. Type: integer.
-        """
-        return pulumi.get(self, "connection_timeout")
-
-    @connection_timeout.setter
-    def connection_timeout(self, value: Optional[Any]):
-        pulumi.set(self, "connection_timeout", value)
-
-    @property
-    @pulumi.getter(name="convertZeroDateTime")
-    def convert_zero_date_time(self) -> Optional[Any]:
-        """
-        True to return DateTime.MinValue for date or datetime columns that have disallowed values. Type: boolean.
-        """
-        return pulumi.get(self, "convert_zero_date_time")
-
-    @convert_zero_date_time.setter
-    def convert_zero_date_time(self, value: Optional[Any]):
-        pulumi.set(self, "convert_zero_date_time", value)
-
     @property
     @pulumi.getter
     def database(self) -> Optional[Any]:
@@ -73962,18 +73650,6 @@ class MySqlLinkedServiceArgs:
     def encrypted_credential(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "encrypted_credential", value)
 
-    @property
-    @pulumi.getter(name="guidFormat")
-    def guid_format(self) -> Optional[Any]:
-        """
-        Determines which column type (if any) should be read as a GUID. Type: string. None: No column types are automatically read as a Guid; Char36: All CHAR(36) columns are read/written as a Guid using lowercase hex with hyphens, which matches UUID.
-        """
-        return pulumi.get(self, "guid_format")
-
-    @guid_format.setter
-    def guid_format(self, value: Optional[Any]):
-        pulumi.set(self, "guid_format", value)
-
     @property
     @pulumi.getter
     def parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['ParameterSpecificationArgs']]]]:
@@ -74022,30 +73698,6 @@ class MySqlLinkedServiceArgs:
     def server(self, value: Optional[Any]):
         pulumi.set(self, "server", value)
 
-    @property
-    @pulumi.getter(name="sslCert")
-    def ssl_cert(self) -> Optional[Any]:
-        """
-        The path to the client’s SSL certificate file in PEM format. SslKey must also be specified. Type: string.
-        """
-        return pulumi.get(self, "ssl_cert")
-
-    @ssl_cert.setter
-    def ssl_cert(self, value: Optional[Any]):
-        pulumi.set(self, "ssl_cert", value)
-
-    @property
-    @pulumi.getter(name="sslKey")
-    def ssl_key(self) -> Optional[Any]:
-        """
-        The path to the client’s SSL private key in PEM format. SslCert must also be specified. Type: string.
-        """
-        return pulumi.get(self, "ssl_key")
-
-    @ssl_key.setter
-    def ssl_key(self, value: Optional[Any]):
-        pulumi.set(self, "ssl_key", value)
-
     @property
     @pulumi.getter(name="sslMode")
     def ssl_mode(self) -> Optional[Any]:
@@ -74058,18 +73710,6 @@ class MySqlLinkedServiceArgs:
     def ssl_mode(self, value: Optional[Any]):
         pulumi.set(self, "ssl_mode", value)
 
-    @property
-    @pulumi.getter(name="treatTinyAsBoolean")
-    def treat_tiny_as_boolean(self) -> Optional[Any]:
-        """
-        When set to true, TINYINT(1) values are returned as booleans. Type: bool.
-        """
-        return pulumi.get(self, "treat_tiny_as_boolean")
-
-    @treat_tiny_as_boolean.setter
-    def treat_tiny_as_boolean(self, value: Optional[Any]):
-        pulumi.set(self, "treat_tiny_as_boolean", value)
-
     @property
     @pulumi.getter(name="useSystemTrustStore")
     def use_system_trust_store(self) -> Optional[Any]: