Chilkat Online Tools

ModifyEndpoint Perl Example

AWS Database Migration Service

use chilkat();

# This example requires the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

$rest = chilkat::CkRest->new();

$authAws = chilkat::CkAuthAws->new();
$authAws->put_AccessKey("AWS_ACCESS_KEY");
$authAws->put_SecretKey("AWS_SECRET_KEY");

# Don't forget to change the region to your particular region. (Also make the same change in the call to Connect below.)
$authAws->put_Region("us-west-2");
$authAws->put_ServiceName("dms");
# SetAuthAws causes Chilkat to automatically add the following headers: Authorization, X-Amz-Date
$rest->SetAuthAws($authAws);

# URL: https://dms.us-west-2.amazonaws.com/
# Use the same region as specified above.
$success = $rest->Connect("dms.us-west-2.amazonaws.com",443,1,1);
if ($success != 1) {
    print "ConnectFailReason: " . $rest->get_ConnectFailReason() . "\r\n";
    print $rest->lastErrorText() . "\r\n";
    exit;
}

# The following code creates the JSON request body.
# The JSON created by this code is shown below.

# Use this online tool to generate code from sample JSON:
# Generate Code to Create JSON

$json = chilkat::CkJsonObject->new();
$json->UpdateString("CertificateArn","string");
$json->UpdateString("DatabaseName","string");
$json->UpdateString("DmsTransferSettings.BucketName","string");
$json->UpdateString("DmsTransferSettings.ServiceAccessRoleArn","string");
$json->UpdateString("DocDbSettings.DatabaseName","string");
$json->UpdateInt("DocDbSettings.DocsToInvestigate",123);
$json->UpdateInt("DocDbSettings.ExtractDocId",123);
$json->UpdateString("DocDbSettings.KmsKeyId","string");
$json->UpdateString("DocDbSettings.NestingLevel","string");
$json->UpdateString("DocDbSettings.Password","string");
$json->UpdateInt("DocDbSettings.Port",123);
$json->UpdateString("DocDbSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("DocDbSettings.SecretsManagerSecretId","string");
$json->UpdateString("DocDbSettings.ServerName","string");
$json->UpdateString("DocDbSettings.Username","string");
$json->UpdateString("DynamoDbSettings.ServiceAccessRoleArn","string");
$json->UpdateString("ElasticsearchSettings.EndpointUri","string");
$json->UpdateInt("ElasticsearchSettings.ErrorRetryDuration",123);
$json->UpdateInt("ElasticsearchSettings.FullLoadErrorPercentage",123);
$json->UpdateString("ElasticsearchSettings.ServiceAccessRoleArn","string");
$json->UpdateString("EndpointArn","string");
$json->UpdateString("EndpointIdentifier","string");
$json->UpdateString("EndpointType","string");
$json->UpdateString("EngineName","string");
$json->UpdateInt("ExactSettings",123);
$json->UpdateString("ExternalTableDefinition","string");
$json->UpdateString("ExtraConnectionAttributes","string");
$json->UpdateString("GcpMySQLSettings.AfterConnectScript","string");
$json->UpdateInt("GcpMySQLSettings.CleanSourceMetadataOnMismatch",123);
$json->UpdateString("GcpMySQLSettings.DatabaseName","string");
$json->UpdateInt("GcpMySQLSettings.EventsPollInterval",123);
$json->UpdateInt("GcpMySQLSettings.MaxFileSize",123);
$json->UpdateInt("GcpMySQLSettings.ParallelLoadThreads",123);
$json->UpdateString("GcpMySQLSettings.Password","string");
$json->UpdateInt("GcpMySQLSettings.Port",123);
$json->UpdateString("GcpMySQLSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("GcpMySQLSettings.SecretsManagerSecretId","string");
$json->UpdateString("GcpMySQLSettings.ServerName","string");
$json->UpdateString("GcpMySQLSettings.ServerTimezone","string");
$json->UpdateString("GcpMySQLSettings.TargetDbType","string");
$json->UpdateString("GcpMySQLSettings.Username","string");
$json->UpdateString("IBMDb2Settings.CurrentLsn","string");
$json->UpdateString("IBMDb2Settings.DatabaseName","string");
$json->UpdateInt("IBMDb2Settings.MaxKBytesPerRead",123);
$json->UpdateString("IBMDb2Settings.Password","string");
$json->UpdateInt("IBMDb2Settings.Port",123);
$json->UpdateString("IBMDb2Settings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("IBMDb2Settings.SecretsManagerSecretId","string");
$json->UpdateString("IBMDb2Settings.ServerName","string");
$json->UpdateInt("IBMDb2Settings.SetDataCaptureChanges",123);
$json->UpdateString("IBMDb2Settings.Username","string");
$json->UpdateString("KafkaSettings.Broker","string");
$json->UpdateInt("KafkaSettings.IncludeControlDetails",123);
$json->UpdateInt("KafkaSettings.IncludeNullAndEmpty",123);
$json->UpdateInt("KafkaSettings.IncludePartitionValue",123);
$json->UpdateInt("KafkaSettings.IncludeTableAlterOperations",123);
$json->UpdateInt("KafkaSettings.IncludeTransactionDetails",123);
$json->UpdateString("KafkaSettings.MessageFormat","string");
$json->UpdateInt("KafkaSettings.MessageMaxBytes",123);
$json->UpdateInt("KafkaSettings.NoHexPrefix",123);
$json->UpdateInt("KafkaSettings.PartitionIncludeSchemaTable",123);
$json->UpdateString("KafkaSettings.SaslPassword","string");
$json->UpdateString("KafkaSettings.SaslUsername","string");
$json->UpdateString("KafkaSettings.SecurityProtocol","string");
$json->UpdateString("KafkaSettings.SslCaCertificateArn","string");
$json->UpdateString("KafkaSettings.SslClientCertificateArn","string");
$json->UpdateString("KafkaSettings.SslClientKeyArn","string");
$json->UpdateString("KafkaSettings.SslClientKeyPassword","string");
$json->UpdateString("KafkaSettings.Topic","string");
$json->UpdateInt("KinesisSettings.IncludeControlDetails",123);
$json->UpdateInt("KinesisSettings.IncludeNullAndEmpty",123);
$json->UpdateInt("KinesisSettings.IncludePartitionValue",123);
$json->UpdateInt("KinesisSettings.IncludeTableAlterOperations",123);
$json->UpdateInt("KinesisSettings.IncludeTransactionDetails",123);
$json->UpdateString("KinesisSettings.MessageFormat","string");
$json->UpdateInt("KinesisSettings.NoHexPrefix",123);
$json->UpdateInt("KinesisSettings.PartitionIncludeSchemaTable",123);
$json->UpdateString("KinesisSettings.ServiceAccessRoleArn","string");
$json->UpdateString("KinesisSettings.StreamArn","string");
$json->UpdateInt("MicrosoftSQLServerSettings.BcpPacketSize",123);
$json->UpdateString("MicrosoftSQLServerSettings.ControlTablesFileGroup","string");
$json->UpdateString("MicrosoftSQLServerSettings.DatabaseName","string");
$json->UpdateString("MicrosoftSQLServerSettings.Password","string");
$json->UpdateInt("MicrosoftSQLServerSettings.Port",123);
$json->UpdateInt("MicrosoftSQLServerSettings.QuerySingleAlwaysOnNode",123);
$json->UpdateInt("MicrosoftSQLServerSettings.ReadBackupOnly",123);
$json->UpdateString("MicrosoftSQLServerSettings.SafeguardPolicy","string");
$json->UpdateString("MicrosoftSQLServerSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("MicrosoftSQLServerSettings.SecretsManagerSecretId","string");
$json->UpdateString("MicrosoftSQLServerSettings.ServerName","string");
$json->UpdateInt("MicrosoftSQLServerSettings.UseBcpFullLoad",123);
$json->UpdateString("MicrosoftSQLServerSettings.Username","string");
$json->UpdateInt("MicrosoftSQLServerSettings.UseThirdPartyBackupDevice",123);
$json->UpdateString("MongoDbSettings.AuthMechanism","string");
$json->UpdateString("MongoDbSettings.AuthSource","string");
$json->UpdateString("MongoDbSettings.AuthType","string");
$json->UpdateString("MongoDbSettings.DatabaseName","string");
$json->UpdateString("MongoDbSettings.DocsToInvestigate","string");
$json->UpdateString("MongoDbSettings.ExtractDocId","string");
$json->UpdateString("MongoDbSettings.KmsKeyId","string");
$json->UpdateString("MongoDbSettings.NestingLevel","string");
$json->UpdateString("MongoDbSettings.Password","string");
$json->UpdateInt("MongoDbSettings.Port",123);
$json->UpdateString("MongoDbSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("MongoDbSettings.SecretsManagerSecretId","string");
$json->UpdateString("MongoDbSettings.ServerName","string");
$json->UpdateString("MongoDbSettings.Username","string");
$json->UpdateString("MySQLSettings.AfterConnectScript","string");
$json->UpdateInt("MySQLSettings.CleanSourceMetadataOnMismatch",123);
$json->UpdateString("MySQLSettings.DatabaseName","string");
$json->UpdateInt("MySQLSettings.EventsPollInterval",123);
$json->UpdateInt("MySQLSettings.MaxFileSize",123);
$json->UpdateInt("MySQLSettings.ParallelLoadThreads",123);
$json->UpdateString("MySQLSettings.Password","string");
$json->UpdateInt("MySQLSettings.Port",123);
$json->UpdateString("MySQLSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("MySQLSettings.SecretsManagerSecretId","string");
$json->UpdateString("MySQLSettings.ServerName","string");
$json->UpdateString("MySQLSettings.ServerTimezone","string");
$json->UpdateString("MySQLSettings.TargetDbType","string");
$json->UpdateString("MySQLSettings.Username","string");
$json->UpdateInt("NeptuneSettings.ErrorRetryDuration",123);
$json->UpdateInt("NeptuneSettings.IamAuthEnabled",123);
$json->UpdateInt("NeptuneSettings.MaxFileSize",123);
$json->UpdateInt("NeptuneSettings.MaxRetryCount",123);
$json->UpdateString("NeptuneSettings.S3BucketFolder","string");
$json->UpdateString("NeptuneSettings.S3BucketName","string");
$json->UpdateString("NeptuneSettings.ServiceAccessRoleArn","string");
$json->UpdateInt("OracleSettings.AccessAlternateDirectly",123);
$json->UpdateInt("OracleSettings.AdditionalArchivedLogDestId",123);
$json->UpdateInt("OracleSettings.AddSupplementalLogging",123);
$json->UpdateInt("OracleSettings.AllowSelectNestedTables",123);
$json->UpdateInt("OracleSettings.ArchivedLogDestId",123);
$json->UpdateInt("OracleSettings.ArchivedLogsOnly",123);
$json->UpdateString("OracleSettings.AsmPassword","string");
$json->UpdateString("OracleSettings.AsmServer","string");
$json->UpdateString("OracleSettings.AsmUser","string");
$json->UpdateString("OracleSettings.CharLengthSemantics","string");
$json->UpdateString("OracleSettings.DatabaseName","string");
$json->UpdateInt("OracleSettings.DirectPathNoLog",123);
$json->UpdateInt("OracleSettings.DirectPathParallelLoad",123);
$json->UpdateInt("OracleSettings.EnableHomogenousTablespace",123);
ERROR: Undefined variable(number)
ERROR: Undefined variable(number)
ERROR: Undefined variable(number)
$json->UpdateInt("OracleSettings.ExtraArchivedLogDestIds[0]",$number);ERROR: Undefined variable(number)
ERROR: Undefined variable(number)
ERROR: Undefined variable(number)
ERROR: Undefined variable(number)
ERROR: Undefined variable(number)

$json->UpdateInt("OracleSettings.FailTasksOnLobTruncation",123);
$json->UpdateInt("OracleSettings.NumberDatatypeScale",123);
$json->UpdateString("OracleSettings.OraclePathPrefix","string");
$json->UpdateInt("OracleSettings.ParallelAsmReadThreads",123);
$json->UpdateString("OracleSettings.Password","string");
$json->UpdateInt("OracleSettings.Port",123);
$json->UpdateInt("OracleSettings.ReadAheadBlocks",123);
$json->UpdateInt("OracleSettings.ReadTableSpaceName",123);
$json->UpdateInt("OracleSettings.ReplacePathPrefix",123);
$json->UpdateInt("OracleSettings.RetryInterval",123);
$json->UpdateString("OracleSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("OracleSettings.SecretsManagerOracleAsmAccessRoleArn","string");
$json->UpdateString("OracleSettings.SecretsManagerOracleAsmSecretId","string");
$json->UpdateString("OracleSettings.SecretsManagerSecretId","string");
$json->UpdateString("OracleSettings.SecurityDbEncryption","string");
$json->UpdateString("OracleSettings.SecurityDbEncryptionName","string");
$json->UpdateString("OracleSettings.ServerName","string");
$json->UpdateString("OracleSettings.SpatialDataOptionToGeoJsonFunctionName","string");
$json->UpdateInt("OracleSettings.StandbyDelayTime",123);
$json->UpdateInt("OracleSettings.UseAlternateFolderForOnline",123);
$json->UpdateInt("OracleSettings.UseBFile",123);
$json->UpdateInt("OracleSettings.UseDirectPathFullLoad",123);
$json->UpdateInt("OracleSettings.UseLogminerReader",123);
$json->UpdateString("OracleSettings.UsePathPrefix","string");
$json->UpdateString("OracleSettings.Username","string");
$json->UpdateString("Password","string");
$json->UpdateInt("Port",123);
$json->UpdateString("PostgreSQLSettings.AfterConnectScript","string");
$json->UpdateInt("PostgreSQLSettings.CaptureDdls",123);
$json->UpdateString("PostgreSQLSettings.DatabaseName","string");
$json->UpdateString("PostgreSQLSettings.DdlArtifactsSchema","string");
$json->UpdateInt("PostgreSQLSettings.ExecuteTimeout",123);
$json->UpdateInt("PostgreSQLSettings.FailTasksOnLobTruncation",123);
$json->UpdateInt("PostgreSQLSettings.HeartbeatEnable",123);
$json->UpdateInt("PostgreSQLSettings.HeartbeatFrequency",123);
$json->UpdateString("PostgreSQLSettings.HeartbeatSchema","string");
$json->UpdateInt("PostgreSQLSettings.MaxFileSize",123);
$json->UpdateString("PostgreSQLSettings.Password","string");
$json->UpdateString("PostgreSQLSettings.PluginName","string");
$json->UpdateInt("PostgreSQLSettings.Port",123);
$json->UpdateString("PostgreSQLSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("PostgreSQLSettings.SecretsManagerSecretId","string");
$json->UpdateString("PostgreSQLSettings.ServerName","string");
$json->UpdateString("PostgreSQLSettings.SlotName","string");
$json->UpdateString("PostgreSQLSettings.Username","string");
$json->UpdateString("RedisSettings.AuthPassword","string");
$json->UpdateString("RedisSettings.AuthType","string");
$json->UpdateString("RedisSettings.AuthUserName","string");
$json->UpdateInt("RedisSettings.Port",123);
$json->UpdateString("RedisSettings.ServerName","string");
$json->UpdateString("RedisSettings.SslCaCertificateArn","string");
$json->UpdateString("RedisSettings.SslSecurityProtocol","string");
$json->UpdateInt("RedshiftSettings.AcceptAnyDate",123);
$json->UpdateString("RedshiftSettings.AfterConnectScript","string");
$json->UpdateString("RedshiftSettings.BucketFolder","string");
$json->UpdateString("RedshiftSettings.BucketName","string");
$json->UpdateInt("RedshiftSettings.CaseSensitiveNames",123);
$json->UpdateInt("RedshiftSettings.CompUpdate",123);
$json->UpdateInt("RedshiftSettings.ConnectionTimeout",123);
$json->UpdateString("RedshiftSettings.DatabaseName","string");
$json->UpdateString("RedshiftSettings.DateFormat","string");
$json->UpdateInt("RedshiftSettings.EmptyAsNull",123);
$json->UpdateString("RedshiftSettings.EncryptionMode","string");
$json->UpdateInt("RedshiftSettings.ExplicitIds",123);
$json->UpdateInt("RedshiftSettings.FileTransferUploadStreams",123);
$json->UpdateInt("RedshiftSettings.LoadTimeout",123);
$json->UpdateInt("RedshiftSettings.MaxFileSize",123);
$json->UpdateString("RedshiftSettings.Password","string");
$json->UpdateInt("RedshiftSettings.Port",123);
$json->UpdateInt("RedshiftSettings.RemoveQuotes",123);
$json->UpdateString("RedshiftSettings.ReplaceChars","string");
$json->UpdateString("RedshiftSettings.ReplaceInvalidChars","string");
$json->UpdateString("RedshiftSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("RedshiftSettings.SecretsManagerSecretId","string");
$json->UpdateString("RedshiftSettings.ServerName","string");
$json->UpdateString("RedshiftSettings.ServerSideEncryptionKmsKeyId","string");
$json->UpdateString("RedshiftSettings.ServiceAccessRoleArn","string");
$json->UpdateString("RedshiftSettings.TimeFormat","string");
$json->UpdateInt("RedshiftSettings.TrimBlanks",123);
$json->UpdateInt("RedshiftSettings.TruncateColumns",123);
$json->UpdateString("RedshiftSettings.Username","string");
$json->UpdateInt("RedshiftSettings.WriteBufferSize",123);
$json->UpdateInt("S3Settings.AddColumnName",123);
$json->UpdateString("S3Settings.BucketFolder","string");
$json->UpdateString("S3Settings.BucketName","string");
$json->UpdateString("S3Settings.CannedAclForObjects","string");
$json->UpdateInt("S3Settings.CdcInsertsAndUpdates",123);
$json->UpdateInt("S3Settings.CdcInsertsOnly",123);
$json->UpdateInt("S3Settings.CdcMaxBatchInterval",123);
$json->UpdateInt("S3Settings.CdcMinFileSize",123);
$json->UpdateString("S3Settings.CdcPath","string");
$json->UpdateString("S3Settings.CompressionType","string");
$json->UpdateString("S3Settings.CsvDelimiter","string");
$json->UpdateString("S3Settings.CsvNoSupValue","string");
$json->UpdateString("S3Settings.CsvNullValue","string");
$json->UpdateString("S3Settings.CsvRowDelimiter","string");
$json->UpdateString("S3Settings.DataFormat","string");
$json->UpdateInt("S3Settings.DataPageSize",123);
$json->UpdateString("S3Settings.DatePartitionDelimiter","string");
$json->UpdateInt("S3Settings.DatePartitionEnabled",123);
$json->UpdateString("S3Settings.DatePartitionSequence","string");
$json->UpdateString("S3Settings.DatePartitionTimezone","string");
$json->UpdateInt("S3Settings.DictPageSizeLimit",123);
$json->UpdateInt("S3Settings.EnableStatistics",123);
$json->UpdateString("S3Settings.EncodingType","string");
$json->UpdateString("S3Settings.EncryptionMode","string");
$json->UpdateString("S3Settings.ExternalTableDefinition","string");
$json->UpdateInt("S3Settings.IgnoreHeaderRows",123);
$json->UpdateInt("S3Settings.IncludeOpForFullLoad",123);
$json->UpdateInt("S3Settings.MaxFileSize",123);
$json->UpdateInt("S3Settings.ParquetTimestampInMillisecond",123);
$json->UpdateString("S3Settings.ParquetVersion","string");
$json->UpdateInt("S3Settings.PreserveTransactions",123);
$json->UpdateInt("S3Settings.Rfc4180",123);
$json->UpdateInt("S3Settings.RowGroupLength",123);
$json->UpdateString("S3Settings.ServerSideEncryptionKmsKeyId","string");
$json->UpdateString("S3Settings.ServiceAccessRoleArn","string");
$json->UpdateString("S3Settings.TimestampColumnName","string");
$json->UpdateInt("S3Settings.UseCsvNoSupValue",123);
$json->UpdateInt("S3Settings.UseTaskStartTimeForFullLoadTimestamp",123);
$json->UpdateString("ServerName","string");
$json->UpdateString("ServiceAccessRoleArn","string");
$json->UpdateString("SslMode","string");
$json->UpdateString("SybaseSettings.DatabaseName","string");
$json->UpdateString("SybaseSettings.Password","string");
$json->UpdateInt("SybaseSettings.Port",123);
$json->UpdateString("SybaseSettings.SecretsManagerAccessRoleArn","string");
$json->UpdateString("SybaseSettings.SecretsManagerSecretId","string");
$json->UpdateString("SybaseSettings.ServerName","string");
$json->UpdateString("SybaseSettings.Username","string");
$json->UpdateString("Username","string");

# The JSON request body created by the above code:

# {
#   "CertificateArn": "string",
#   "DatabaseName": "string",
#   "DmsTransferSettings": {
#     "BucketName": "string",
#     "ServiceAccessRoleArn": "string"
#   },
#   "DocDbSettings": {
#     "DatabaseName": "string",
#     "DocsToInvestigate": number,
#     "ExtractDocId": boolean,
#     "KmsKeyId": "string",
#     "NestingLevel": "string",
#     "Password": "string",
#     "Port": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "Username": "string"
#   },
#   "DynamoDbSettings": {
#     "ServiceAccessRoleArn": "string"
#   },
#   "ElasticsearchSettings": {
#     "EndpointUri": "string",
#     "ErrorRetryDuration": number,
#     "FullLoadErrorPercentage": number,
#     "ServiceAccessRoleArn": "string"
#   },
#   "EndpointArn": "string",
#   "EndpointIdentifier": "string",
#   "EndpointType": "string",
#   "EngineName": "string",
#   "ExactSettings": boolean,
#   "ExternalTableDefinition": "string",
#   "ExtraConnectionAttributes": "string",
#   "GcpMySQLSettings": {
#     "AfterConnectScript": "string",
#     "CleanSourceMetadataOnMismatch": boolean,
#     "DatabaseName": "string",
#     "EventsPollInterval": number,
#     "MaxFileSize": number,
#     "ParallelLoadThreads": number,
#     "Password": "string",
#     "Port": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "ServerTimezone": "string",
#     "TargetDbType": "string",
#     "Username": "string"
#   },
#   "IBMDb2Settings": {
#     "CurrentLsn": "string",
#     "DatabaseName": "string",
#     "MaxKBytesPerRead": number,
#     "Password": "string",
#     "Port": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "SetDataCaptureChanges": boolean,
#     "Username": "string"
#   },
#   "KafkaSettings": {
#     "Broker": "string",
#     "IncludeControlDetails": boolean,
#     "IncludeNullAndEmpty": boolean,
#     "IncludePartitionValue": boolean,
#     "IncludeTableAlterOperations": boolean,
#     "IncludeTransactionDetails": boolean,
#     "MessageFormat": "string",
#     "MessageMaxBytes": number,
#     "NoHexPrefix": boolean,
#     "PartitionIncludeSchemaTable": boolean,
#     "SaslPassword": "string",
#     "SaslUsername": "string",
#     "SecurityProtocol": "string",
#     "SslCaCertificateArn": "string",
#     "SslClientCertificateArn": "string",
#     "SslClientKeyArn": "string",
#     "SslClientKeyPassword": "string",
#     "Topic": "string"
#   },
#   "KinesisSettings": {
#     "IncludeControlDetails": boolean,
#     "IncludeNullAndEmpty": boolean,
#     "IncludePartitionValue": boolean,
#     "IncludeTableAlterOperations": boolean,
#     "IncludeTransactionDetails": boolean,
#     "MessageFormat": "string",
#     "NoHexPrefix": boolean,
#     "PartitionIncludeSchemaTable": boolean,
#     "ServiceAccessRoleArn": "string",
#     "StreamArn": "string"
#   },
#   "MicrosoftSQLServerSettings": {
#     "BcpPacketSize": number,
#     "ControlTablesFileGroup": "string",
#     "DatabaseName": "string",
#     "Password": "string",
#     "Port": number,
#     "QuerySingleAlwaysOnNode": boolean,
#     "ReadBackupOnly": boolean,
#     "SafeguardPolicy": "string",
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "UseBcpFullLoad": boolean,
#     "Username": "string",
#     "UseThirdPartyBackupDevice": boolean
#   },
#   "MongoDbSettings": {
#     "AuthMechanism": "string",
#     "AuthSource": "string",
#     "AuthType": "string",
#     "DatabaseName": "string",
#     "DocsToInvestigate": "string",
#     "ExtractDocId": "string",
#     "KmsKeyId": "string",
#     "NestingLevel": "string",
#     "Password": "string",
#     "Port": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "Username": "string"
#   },
#   "MySQLSettings": {
#     "AfterConnectScript": "string",
#     "CleanSourceMetadataOnMismatch": boolean,
#     "DatabaseName": "string",
#     "EventsPollInterval": number,
#     "MaxFileSize": number,
#     "ParallelLoadThreads": number,
#     "Password": "string",
#     "Port": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "ServerTimezone": "string",
#     "TargetDbType": "string",
#     "Username": "string"
#   },
#   "NeptuneSettings": {
#     "ErrorRetryDuration": number,
#     "IamAuthEnabled": boolean,
#     "MaxFileSize": number,
#     "MaxRetryCount": number,
#     "S3BucketFolder": "string",
#     "S3BucketName": "string",
#     "ServiceAccessRoleArn": "string"
#   },
#   "OracleSettings": {
#     "AccessAlternateDirectly": boolean,
#     "AdditionalArchivedLogDestId": number,
#     "AddSupplementalLogging": boolean,
#     "AllowSelectNestedTables": boolean,
#     "ArchivedLogDestId": number,
#     "ArchivedLogsOnly": boolean,
#     "AsmPassword": "string",
#     "AsmServer": "string",
#     "AsmUser": "string",
#     "CharLengthSemantics": "string",
#     "DatabaseName": "string",
#     "DirectPathNoLog": boolean,
#     "DirectPathParallelLoad": boolean,
#     "EnableHomogenousTablespace": boolean,
#     "ExtraArchivedLogDestIds": [
#       number
#     ],
#     "FailTasksOnLobTruncation": boolean,
#     "NumberDatatypeScale": number,
#     "OraclePathPrefix": "string",
#     "ParallelAsmReadThreads": number,
#     "Password": "string",
#     "Port": number,
#     "ReadAheadBlocks": number,
#     "ReadTableSpaceName": boolean,
#     "ReplacePathPrefix": boolean,
#     "RetryInterval": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerOracleAsmAccessRoleArn": "string",
#     "SecretsManagerOracleAsmSecretId": "string",
#     "SecretsManagerSecretId": "string",
#     "SecurityDbEncryption": "string",
#     "SecurityDbEncryptionName": "string",
#     "ServerName": "string",
#     "SpatialDataOptionToGeoJsonFunctionName": "string",
#     "StandbyDelayTime": number,
#     "UseAlternateFolderForOnline": boolean,
#     "UseBFile": boolean,
#     "UseDirectPathFullLoad": boolean,
#     "UseLogminerReader": boolean,
#     "UsePathPrefix": "string",
#     "Username": "string"
#   },
#   "Password": "string",
#   "Port": number,
#   "PostgreSQLSettings": {
#     "AfterConnectScript": "string",
#     "CaptureDdls": boolean,
#     "DatabaseName": "string",
#     "DdlArtifactsSchema": "string",
#     "ExecuteTimeout": number,
#     "FailTasksOnLobTruncation": boolean,
#     "HeartbeatEnable": boolean,
#     "HeartbeatFrequency": number,
#     "HeartbeatSchema": "string",
#     "MaxFileSize": number,
#     "Password": "string",
#     "PluginName": "string",
#     "Port": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "SlotName": "string",
#     "Username": "string"
#   },
#   "RedisSettings": {
#     "AuthPassword": "string",
#     "AuthType": "string",
#     "AuthUserName": "string",
#     "Port": number,
#     "ServerName": "string",
#     "SslCaCertificateArn": "string",
#     "SslSecurityProtocol": "string"
#   },
#   "RedshiftSettings": {
#     "AcceptAnyDate": boolean,
#     "AfterConnectScript": "string",
#     "BucketFolder": "string",
#     "BucketName": "string",
#     "CaseSensitiveNames": boolean,
#     "CompUpdate": boolean,
#     "ConnectionTimeout": number,
#     "DatabaseName": "string",
#     "DateFormat": "string",
#     "EmptyAsNull": boolean,
#     "EncryptionMode": "string",
#     "ExplicitIds": boolean,
#     "FileTransferUploadStreams": number,
#     "LoadTimeout": number,
#     "MaxFileSize": number,
#     "Password": "string",
#     "Port": number,
#     "RemoveQuotes": boolean,
#     "ReplaceChars": "string",
#     "ReplaceInvalidChars": "string",
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "ServerSideEncryptionKmsKeyId": "string",
#     "ServiceAccessRoleArn": "string",
#     "TimeFormat": "string",
#     "TrimBlanks": boolean,
#     "TruncateColumns": boolean,
#     "Username": "string",
#     "WriteBufferSize": number
#   },
#   "S3Settings": {
#     "AddColumnName": boolean,
#     "BucketFolder": "string",
#     "BucketName": "string",
#     "CannedAclForObjects": "string",
#     "CdcInsertsAndUpdates": boolean,
#     "CdcInsertsOnly": boolean,
#     "CdcMaxBatchInterval": number,
#     "CdcMinFileSize": number,
#     "CdcPath": "string",
#     "CompressionType": "string",
#     "CsvDelimiter": "string",
#     "CsvNoSupValue": "string",
#     "CsvNullValue": "string",
#     "CsvRowDelimiter": "string",
#     "DataFormat": "string",
#     "DataPageSize": number,
#     "DatePartitionDelimiter": "string",
#     "DatePartitionEnabled": boolean,
#     "DatePartitionSequence": "string",
#     "DatePartitionTimezone": "string",
#     "DictPageSizeLimit": number,
#     "EnableStatistics": boolean,
#     "EncodingType": "string",
#     "EncryptionMode": "string",
#     "ExternalTableDefinition": "string",
#     "IgnoreHeaderRows": number,
#     "IncludeOpForFullLoad": boolean,
#     "MaxFileSize": number,
#     "ParquetTimestampInMillisecond": boolean,
#     "ParquetVersion": "string",
#     "PreserveTransactions": boolean,
#     "Rfc4180": boolean,
#     "RowGroupLength": number,
#     "ServerSideEncryptionKmsKeyId": "string",
#     "ServiceAccessRoleArn": "string",
#     "TimestampColumnName": "string",
#     "UseCsvNoSupValue": boolean,
#     "UseTaskStartTimeForFullLoadTimestamp": boolean
#   },
#   "ServerName": "string",
#   "ServiceAccessRoleArn": "string",
#   "SslMode": "string",
#   "SybaseSettings": {
#     "DatabaseName": "string",
#     "Password": "string",
#     "Port": number,
#     "SecretsManagerAccessRoleArn": "string",
#     "SecretsManagerSecretId": "string",
#     "ServerName": "string",
#     "Username": "string"
#   },
#   "Username": "string"
# }

$rest->AddHeader("Content-Type","application/x-amz-json-1.1");
$rest->AddHeader("X-Amz-Target","AmazonDMSv20160101.ModifyEndpoint");

$sbRequestBody = chilkat::CkStringBuilder->new();
$json->EmitSb($sbRequestBody);
$sbResponseBody = chilkat::CkStringBuilder->new();
$success = $rest->FullRequestSb("POST","/",$sbRequestBody,$sbResponseBody);
if ($success != 1) {
    print $rest->lastErrorText() . "\r\n";
    exit;
}

$respStatusCode = $rest->get_ResponseStatusCode();
print "response status code = " . $respStatusCode . "\r\n";
if ($respStatusCode != 200) {
    print "Response Header:" . "\r\n";
    print $rest->responseHeader() . "\r\n";
    print "Response Body:" . "\r\n";
    print $sbResponseBody->getAsString() . "\r\n";
    exit;
}

$jResp = chilkat::CkJsonObject->new();
$jResp->LoadSb($sbResponseBody);

# The following code parses the JSON response.
# A sample JSON response is shown below the sample code.

# Use this online tool to generate parsing code from sample JSON:
# Generate Parsing Code from JSON

$CertificateArn = $jResp->stringOf("Endpoint.CertificateArn");
$DatabaseName = $jResp->stringOf("Endpoint.DatabaseName");
$BucketName = $jResp->stringOf("Endpoint.DmsTransferSettings.BucketName");
$ServiceAccessRoleArn = $jResp->stringOf("Endpoint.DmsTransferSettings.ServiceAccessRoleArn");
$DocDbSettingsDatabaseName = $jResp->stringOf("Endpoint.DocDbSettings.DatabaseName");
$DocsToInvestigate = $jResp->IntOf("Endpoint.DocDbSettings.DocsToInvestigate");
$ExtractDocId = $jResp->IntOf("Endpoint.DocDbSettings.ExtractDocId");
$KmsKeyId = $jResp->stringOf("Endpoint.DocDbSettings.KmsKeyId");
$NestingLevel = $jResp->stringOf("Endpoint.DocDbSettings.NestingLevel");
$Password = $jResp->stringOf("Endpoint.DocDbSettings.Password");
$Port = $jResp->IntOf("Endpoint.DocDbSettings.Port");
$SecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.DocDbSettings.SecretsManagerAccessRoleArn");
$SecretsManagerSecretId = $jResp->stringOf("Endpoint.DocDbSettings.SecretsManagerSecretId");
$ServerName = $jResp->stringOf("Endpoint.DocDbSettings.ServerName");
$Username = $jResp->stringOf("Endpoint.DocDbSettings.Username");
$DynamoDbSettingsServiceAccessRoleArn = $jResp->stringOf("Endpoint.DynamoDbSettings.ServiceAccessRoleArn");
$EndpointUri = $jResp->stringOf("Endpoint.ElasticsearchSettings.EndpointUri");
$ErrorRetryDuration = $jResp->IntOf("Endpoint.ElasticsearchSettings.ErrorRetryDuration");
$FullLoadErrorPercentage = $jResp->IntOf("Endpoint.ElasticsearchSettings.FullLoadErrorPercentage");
$ElasticsearchSettingsServiceAccessRoleArn = $jResp->stringOf("Endpoint.ElasticsearchSettings.ServiceAccessRoleArn");
$EndpointArn = $jResp->stringOf("Endpoint.EndpointArn");
$EndpointIdentifier = $jResp->stringOf("Endpoint.EndpointIdentifier");
$EndpointType = $jResp->stringOf("Endpoint.EndpointType");
$EngineDisplayName = $jResp->stringOf("Endpoint.EngineDisplayName");
$EngineName = $jResp->stringOf("Endpoint.EngineName");
$ExternalId = $jResp->stringOf("Endpoint.ExternalId");
$ExternalTableDefinition = $jResp->stringOf("Endpoint.ExternalTableDefinition");
$ExtraConnectionAttributes = $jResp->stringOf("Endpoint.ExtraConnectionAttributes");
$AfterConnectScript = $jResp->stringOf("Endpoint.GcpMySQLSettings.AfterConnectScript");
$CleanSourceMetadataOnMismatch = $jResp->IntOf("Endpoint.GcpMySQLSettings.CleanSourceMetadataOnMismatch");
$GcpMySQLSettingsDatabaseName = $jResp->stringOf("Endpoint.GcpMySQLSettings.DatabaseName");
$EventsPollInterval = $jResp->IntOf("Endpoint.GcpMySQLSettings.EventsPollInterval");
$MaxFileSize = $jResp->IntOf("Endpoint.GcpMySQLSettings.MaxFileSize");
$ParallelLoadThreads = $jResp->IntOf("Endpoint.GcpMySQLSettings.ParallelLoadThreads");
$GcpMySQLSettingsPassword = $jResp->stringOf("Endpoint.GcpMySQLSettings.Password");
$GcpMySQLSettingsPort = $jResp->IntOf("Endpoint.GcpMySQLSettings.Port");
$GcpMySQLSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.GcpMySQLSettings.SecretsManagerAccessRoleArn");
$GcpMySQLSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.GcpMySQLSettings.SecretsManagerSecretId");
$GcpMySQLSettingsServerName = $jResp->stringOf("Endpoint.GcpMySQLSettings.ServerName");
$ServerTimezone = $jResp->stringOf("Endpoint.GcpMySQLSettings.ServerTimezone");
$TargetDbType = $jResp->stringOf("Endpoint.GcpMySQLSettings.TargetDbType");
$GcpMySQLSettingsUsername = $jResp->stringOf("Endpoint.GcpMySQLSettings.Username");
$CurrentLsn = $jResp->stringOf("Endpoint.IBMDb2Settings.CurrentLsn");
$IBMDb2SettingsDatabaseName = $jResp->stringOf("Endpoint.IBMDb2Settings.DatabaseName");
$MaxKBytesPerRead = $jResp->IntOf("Endpoint.IBMDb2Settings.MaxKBytesPerRead");
$IBMDb2SettingsPassword = $jResp->stringOf("Endpoint.IBMDb2Settings.Password");
$IBMDb2SettingsPort = $jResp->IntOf("Endpoint.IBMDb2Settings.Port");
$IBMDb2SettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.IBMDb2Settings.SecretsManagerAccessRoleArn");
$IBMDb2SettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.IBMDb2Settings.SecretsManagerSecretId");
$IBMDb2SettingsServerName = $jResp->stringOf("Endpoint.IBMDb2Settings.ServerName");
$SetDataCaptureChanges = $jResp->IntOf("Endpoint.IBMDb2Settings.SetDataCaptureChanges");
$IBMDb2SettingsUsername = $jResp->stringOf("Endpoint.IBMDb2Settings.Username");
$Broker = $jResp->stringOf("Endpoint.KafkaSettings.Broker");
$IncludeControlDetails = $jResp->IntOf("Endpoint.KafkaSettings.IncludeControlDetails");
$IncludeNullAndEmpty = $jResp->IntOf("Endpoint.KafkaSettings.IncludeNullAndEmpty");
$IncludePartitionValue = $jResp->IntOf("Endpoint.KafkaSettings.IncludePartitionValue");
$IncludeTableAlterOperations = $jResp->IntOf("Endpoint.KafkaSettings.IncludeTableAlterOperations");
$IncludeTransactionDetails = $jResp->IntOf("Endpoint.KafkaSettings.IncludeTransactionDetails");
$MessageFormat = $jResp->stringOf("Endpoint.KafkaSettings.MessageFormat");
$MessageMaxBytes = $jResp->IntOf("Endpoint.KafkaSettings.MessageMaxBytes");
$NoHexPrefix = $jResp->IntOf("Endpoint.KafkaSettings.NoHexPrefix");
$PartitionIncludeSchemaTable = $jResp->IntOf("Endpoint.KafkaSettings.PartitionIncludeSchemaTable");
$SaslPassword = $jResp->stringOf("Endpoint.KafkaSettings.SaslPassword");
$SaslUsername = $jResp->stringOf("Endpoint.KafkaSettings.SaslUsername");
$SecurityProtocol = $jResp->stringOf("Endpoint.KafkaSettings.SecurityProtocol");
$SslCaCertificateArn = $jResp->stringOf("Endpoint.KafkaSettings.SslCaCertificateArn");
$SslClientCertificateArn = $jResp->stringOf("Endpoint.KafkaSettings.SslClientCertificateArn");
$SslClientKeyArn = $jResp->stringOf("Endpoint.KafkaSettings.SslClientKeyArn");
$SslClientKeyPassword = $jResp->stringOf("Endpoint.KafkaSettings.SslClientKeyPassword");
$Topic = $jResp->stringOf("Endpoint.KafkaSettings.Topic");
$KinesisSettingsIncludeControlDetails = $jResp->IntOf("Endpoint.KinesisSettings.IncludeControlDetails");
$KinesisSettingsIncludeNullAndEmpty = $jResp->IntOf("Endpoint.KinesisSettings.IncludeNullAndEmpty");
$KinesisSettingsIncludePartitionValue = $jResp->IntOf("Endpoint.KinesisSettings.IncludePartitionValue");
$KinesisSettingsIncludeTableAlterOperations = $jResp->IntOf("Endpoint.KinesisSettings.IncludeTableAlterOperations");
$KinesisSettingsIncludeTransactionDetails = $jResp->IntOf("Endpoint.KinesisSettings.IncludeTransactionDetails");
$KinesisSettingsMessageFormat = $jResp->stringOf("Endpoint.KinesisSettings.MessageFormat");
$KinesisSettingsNoHexPrefix = $jResp->IntOf("Endpoint.KinesisSettings.NoHexPrefix");
$KinesisSettingsPartitionIncludeSchemaTable = $jResp->IntOf("Endpoint.KinesisSettings.PartitionIncludeSchemaTable");
$KinesisSettingsServiceAccessRoleArn = $jResp->stringOf("Endpoint.KinesisSettings.ServiceAccessRoleArn");
$StreamArn = $jResp->stringOf("Endpoint.KinesisSettings.StreamArn");
$EndpointKmsKeyId = $jResp->stringOf("Endpoint.KmsKeyId");
$BcpPacketSize = $jResp->IntOf("Endpoint.MicrosoftSQLServerSettings.BcpPacketSize");
$ControlTablesFileGroup = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.ControlTablesFileGroup");
$MicrosoftSQLServerSettingsDatabaseName = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.DatabaseName");
$MicrosoftSQLServerSettingsPassword = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.Password");
$MicrosoftSQLServerSettingsPort = $jResp->IntOf("Endpoint.MicrosoftSQLServerSettings.Port");
$QuerySingleAlwaysOnNode = $jResp->IntOf("Endpoint.MicrosoftSQLServerSettings.QuerySingleAlwaysOnNode");
$ReadBackupOnly = $jResp->IntOf("Endpoint.MicrosoftSQLServerSettings.ReadBackupOnly");
$SafeguardPolicy = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.SafeguardPolicy");
$MicrosoftSQLServerSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.SecretsManagerAccessRoleArn");
$MicrosoftSQLServerSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.SecretsManagerSecretId");
$MicrosoftSQLServerSettingsServerName = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.ServerName");
$UseBcpFullLoad = $jResp->IntOf("Endpoint.MicrosoftSQLServerSettings.UseBcpFullLoad");
$MicrosoftSQLServerSettingsUsername = $jResp->stringOf("Endpoint.MicrosoftSQLServerSettings.Username");
$UseThirdPartyBackupDevice = $jResp->IntOf("Endpoint.MicrosoftSQLServerSettings.UseThirdPartyBackupDevice");
$AuthMechanism = $jResp->stringOf("Endpoint.MongoDbSettings.AuthMechanism");
$AuthSource = $jResp->stringOf("Endpoint.MongoDbSettings.AuthSource");
$AuthType = $jResp->stringOf("Endpoint.MongoDbSettings.AuthType");
$MongoDbSettingsDatabaseName = $jResp->stringOf("Endpoint.MongoDbSettings.DatabaseName");
$MongoDbSettingsDocsToInvestigate = $jResp->stringOf("Endpoint.MongoDbSettings.DocsToInvestigate");
$MongoDbSettingsExtractDocId = $jResp->stringOf("Endpoint.MongoDbSettings.ExtractDocId");
$MongoDbSettingsKmsKeyId = $jResp->stringOf("Endpoint.MongoDbSettings.KmsKeyId");
$MongoDbSettingsNestingLevel = $jResp->stringOf("Endpoint.MongoDbSettings.NestingLevel");
$MongoDbSettingsPassword = $jResp->stringOf("Endpoint.MongoDbSettings.Password");
$MongoDbSettingsPort = $jResp->IntOf("Endpoint.MongoDbSettings.Port");
$MongoDbSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.MongoDbSettings.SecretsManagerAccessRoleArn");
$MongoDbSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.MongoDbSettings.SecretsManagerSecretId");
$MongoDbSettingsServerName = $jResp->stringOf("Endpoint.MongoDbSettings.ServerName");
$MongoDbSettingsUsername = $jResp->stringOf("Endpoint.MongoDbSettings.Username");
$MySQLSettingsAfterConnectScript = $jResp->stringOf("Endpoint.MySQLSettings.AfterConnectScript");
$MySQLSettingsCleanSourceMetadataOnMismatch = $jResp->IntOf("Endpoint.MySQLSettings.CleanSourceMetadataOnMismatch");
$MySQLSettingsDatabaseName = $jResp->stringOf("Endpoint.MySQLSettings.DatabaseName");
$MySQLSettingsEventsPollInterval = $jResp->IntOf("Endpoint.MySQLSettings.EventsPollInterval");
$MySQLSettingsMaxFileSize = $jResp->IntOf("Endpoint.MySQLSettings.MaxFileSize");
$MySQLSettingsParallelLoadThreads = $jResp->IntOf("Endpoint.MySQLSettings.ParallelLoadThreads");
$MySQLSettingsPassword = $jResp->stringOf("Endpoint.MySQLSettings.Password");
$MySQLSettingsPort = $jResp->IntOf("Endpoint.MySQLSettings.Port");
$MySQLSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.MySQLSettings.SecretsManagerAccessRoleArn");
$MySQLSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.MySQLSettings.SecretsManagerSecretId");
$MySQLSettingsServerName = $jResp->stringOf("Endpoint.MySQLSettings.ServerName");
$MySQLSettingsServerTimezone = $jResp->stringOf("Endpoint.MySQLSettings.ServerTimezone");
$MySQLSettingsTargetDbType = $jResp->stringOf("Endpoint.MySQLSettings.TargetDbType");
$MySQLSettingsUsername = $jResp->stringOf("Endpoint.MySQLSettings.Username");
$NeptuneSettingsErrorRetryDuration = $jResp->IntOf("Endpoint.NeptuneSettings.ErrorRetryDuration");
$IamAuthEnabled = $jResp->IntOf("Endpoint.NeptuneSettings.IamAuthEnabled");
$NeptuneSettingsMaxFileSize = $jResp->IntOf("Endpoint.NeptuneSettings.MaxFileSize");
$MaxRetryCount = $jResp->IntOf("Endpoint.NeptuneSettings.MaxRetryCount");
$S3BucketFolder = $jResp->stringOf("Endpoint.NeptuneSettings.S3BucketFolder");
$S3BucketName = $jResp->stringOf("Endpoint.NeptuneSettings.S3BucketName");
$NeptuneSettingsServiceAccessRoleArn = $jResp->stringOf("Endpoint.NeptuneSettings.ServiceAccessRoleArn");
$AccessAlternateDirectly = $jResp->IntOf("Endpoint.OracleSettings.AccessAlternateDirectly");
$AdditionalArchivedLogDestId = $jResp->IntOf("Endpoint.OracleSettings.AdditionalArchivedLogDestId");
$AddSupplementalLogging = $jResp->IntOf("Endpoint.OracleSettings.AddSupplementalLogging");
$AllowSelectNestedTables = $jResp->IntOf("Endpoint.OracleSettings.AllowSelectNestedTables");
$ArchivedLogDestId = $jResp->IntOf("Endpoint.OracleSettings.ArchivedLogDestId");
$ArchivedLogsOnly = $jResp->IntOf("Endpoint.OracleSettings.ArchivedLogsOnly");
$AsmPassword = $jResp->stringOf("Endpoint.OracleSettings.AsmPassword");
$AsmServer = $jResp->stringOf("Endpoint.OracleSettings.AsmServer");
$AsmUser = $jResp->stringOf("Endpoint.OracleSettings.AsmUser");
$CharLengthSemantics = $jResp->stringOf("Endpoint.OracleSettings.CharLengthSemantics");
$OracleSettingsDatabaseName = $jResp->stringOf("Endpoint.OracleSettings.DatabaseName");
$DirectPathNoLog = $jResp->IntOf("Endpoint.OracleSettings.DirectPathNoLog");
$DirectPathParallelLoad = $jResp->IntOf("Endpoint.OracleSettings.DirectPathParallelLoad");
$EnableHomogenousTablespace = $jResp->IntOf("Endpoint.OracleSettings.EnableHomogenousTablespace");
$FailTasksOnLobTruncation = $jResp->IntOf("Endpoint.OracleSettings.FailTasksOnLobTruncation");
$NumberDatatypeScale = $jResp->IntOf("Endpoint.OracleSettings.NumberDatatypeScale");
$OraclePathPrefix = $jResp->stringOf("Endpoint.OracleSettings.OraclePathPrefix");
$ParallelAsmReadThreads = $jResp->IntOf("Endpoint.OracleSettings.ParallelAsmReadThreads");
$OracleSettingsPassword = $jResp->stringOf("Endpoint.OracleSettings.Password");
$OracleSettingsPort = $jResp->IntOf("Endpoint.OracleSettings.Port");
$ReadAheadBlocks = $jResp->IntOf("Endpoint.OracleSettings.ReadAheadBlocks");
$ReadTableSpaceName = $jResp->IntOf("Endpoint.OracleSettings.ReadTableSpaceName");
$ReplacePathPrefix = $jResp->IntOf("Endpoint.OracleSettings.ReplacePathPrefix");
$RetryInterval = $jResp->IntOf("Endpoint.OracleSettings.RetryInterval");
$OracleSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.OracleSettings.SecretsManagerAccessRoleArn");
$SecretsManagerOracleAsmAccessRoleArn = $jResp->stringOf("Endpoint.OracleSettings.SecretsManagerOracleAsmAccessRoleArn");
$SecretsManagerOracleAsmSecretId = $jResp->stringOf("Endpoint.OracleSettings.SecretsManagerOracleAsmSecretId");
$OracleSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.OracleSettings.SecretsManagerSecretId");
$SecurityDbEncryption = $jResp->stringOf("Endpoint.OracleSettings.SecurityDbEncryption");
$SecurityDbEncryptionName = $jResp->stringOf("Endpoint.OracleSettings.SecurityDbEncryptionName");
$OracleSettingsServerName = $jResp->stringOf("Endpoint.OracleSettings.ServerName");
$SpatialDataOptionToGeoJsonFunctionName = $jResp->stringOf("Endpoint.OracleSettings.SpatialDataOptionToGeoJsonFunctionName");
$StandbyDelayTime = $jResp->IntOf("Endpoint.OracleSettings.StandbyDelayTime");
$UseAlternateFolderForOnline = $jResp->IntOf("Endpoint.OracleSettings.UseAlternateFolderForOnline");
$UseBFile = $jResp->IntOf("Endpoint.OracleSettings.UseBFile");
$UseDirectPathFullLoad = $jResp->IntOf("Endpoint.OracleSettings.UseDirectPathFullLoad");
$UseLogminerReader = $jResp->IntOf("Endpoint.OracleSettings.UseLogminerReader");
$UsePathPrefix = $jResp->stringOf("Endpoint.OracleSettings.UsePathPrefix");
$OracleSettingsUsername = $jResp->stringOf("Endpoint.OracleSettings.Username");
$EndpointPort = $jResp->IntOf("Endpoint.Port");
$PostgreSQLSettingsAfterConnectScript = $jResp->stringOf("Endpoint.PostgreSQLSettings.AfterConnectScript");
$CaptureDdls = $jResp->IntOf("Endpoint.PostgreSQLSettings.CaptureDdls");
$PostgreSQLSettingsDatabaseName = $jResp->stringOf("Endpoint.PostgreSQLSettings.DatabaseName");
$DdlArtifactsSchema = $jResp->stringOf("Endpoint.PostgreSQLSettings.DdlArtifactsSchema");
$ExecuteTimeout = $jResp->IntOf("Endpoint.PostgreSQLSettings.ExecuteTimeout");
$PostgreSQLSettingsFailTasksOnLobTruncation = $jResp->IntOf("Endpoint.PostgreSQLSettings.FailTasksOnLobTruncation");
$HeartbeatEnable = $jResp->IntOf("Endpoint.PostgreSQLSettings.HeartbeatEnable");
$HeartbeatFrequency = $jResp->IntOf("Endpoint.PostgreSQLSettings.HeartbeatFrequency");
$HeartbeatSchema = $jResp->stringOf("Endpoint.PostgreSQLSettings.HeartbeatSchema");
$PostgreSQLSettingsMaxFileSize = $jResp->IntOf("Endpoint.PostgreSQLSettings.MaxFileSize");
$PostgreSQLSettingsPassword = $jResp->stringOf("Endpoint.PostgreSQLSettings.Password");
$PluginName = $jResp->stringOf("Endpoint.PostgreSQLSettings.PluginName");
$PostgreSQLSettingsPort = $jResp->IntOf("Endpoint.PostgreSQLSettings.Port");
$PostgreSQLSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.PostgreSQLSettings.SecretsManagerAccessRoleArn");
$PostgreSQLSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.PostgreSQLSettings.SecretsManagerSecretId");
$PostgreSQLSettingsServerName = $jResp->stringOf("Endpoint.PostgreSQLSettings.ServerName");
$SlotName = $jResp->stringOf("Endpoint.PostgreSQLSettings.SlotName");
$PostgreSQLSettingsUsername = $jResp->stringOf("Endpoint.PostgreSQLSettings.Username");
$AuthPassword = $jResp->stringOf("Endpoint.RedisSettings.AuthPassword");
$RedisSettingsAuthType = $jResp->stringOf("Endpoint.RedisSettings.AuthType");
$AuthUserName = $jResp->stringOf("Endpoint.RedisSettings.AuthUserName");
$RedisSettingsPort = $jResp->IntOf("Endpoint.RedisSettings.Port");
$RedisSettingsServerName = $jResp->stringOf("Endpoint.RedisSettings.ServerName");
$RedisSettingsSslCaCertificateArn = $jResp->stringOf("Endpoint.RedisSettings.SslCaCertificateArn");
$SslSecurityProtocol = $jResp->stringOf("Endpoint.RedisSettings.SslSecurityProtocol");
$AcceptAnyDate = $jResp->IntOf("Endpoint.RedshiftSettings.AcceptAnyDate");
$RedshiftSettingsAfterConnectScript = $jResp->stringOf("Endpoint.RedshiftSettings.AfterConnectScript");
$BucketFolder = $jResp->stringOf("Endpoint.RedshiftSettings.BucketFolder");
$RedshiftSettingsBucketName = $jResp->stringOf("Endpoint.RedshiftSettings.BucketName");
$CaseSensitiveNames = $jResp->IntOf("Endpoint.RedshiftSettings.CaseSensitiveNames");
$CompUpdate = $jResp->IntOf("Endpoint.RedshiftSettings.CompUpdate");
$ConnectionTimeout = $jResp->IntOf("Endpoint.RedshiftSettings.ConnectionTimeout");
$RedshiftSettingsDatabaseName = $jResp->stringOf("Endpoint.RedshiftSettings.DatabaseName");
$DateFormat = $jResp->stringOf("Endpoint.RedshiftSettings.DateFormat");
$EmptyAsNull = $jResp->IntOf("Endpoint.RedshiftSettings.EmptyAsNull");
$EncryptionMode = $jResp->stringOf("Endpoint.RedshiftSettings.EncryptionMode");
$ExplicitIds = $jResp->IntOf("Endpoint.RedshiftSettings.ExplicitIds");
$FileTransferUploadStreams = $jResp->IntOf("Endpoint.RedshiftSettings.FileTransferUploadStreams");
$LoadTimeout = $jResp->IntOf("Endpoint.RedshiftSettings.LoadTimeout");
$RedshiftSettingsMaxFileSize = $jResp->IntOf("Endpoint.RedshiftSettings.MaxFileSize");
$RedshiftSettingsPassword = $jResp->stringOf("Endpoint.RedshiftSettings.Password");
$RedshiftSettingsPort = $jResp->IntOf("Endpoint.RedshiftSettings.Port");
$RemoveQuotes = $jResp->IntOf("Endpoint.RedshiftSettings.RemoveQuotes");
$ReplaceChars = $jResp->stringOf("Endpoint.RedshiftSettings.ReplaceChars");
$ReplaceInvalidChars = $jResp->stringOf("Endpoint.RedshiftSettings.ReplaceInvalidChars");
$RedshiftSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.RedshiftSettings.SecretsManagerAccessRoleArn");
$RedshiftSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.RedshiftSettings.SecretsManagerSecretId");
$RedshiftSettingsServerName = $jResp->stringOf("Endpoint.RedshiftSettings.ServerName");
$ServerSideEncryptionKmsKeyId = $jResp->stringOf("Endpoint.RedshiftSettings.ServerSideEncryptionKmsKeyId");
$RedshiftSettingsServiceAccessRoleArn = $jResp->stringOf("Endpoint.RedshiftSettings.ServiceAccessRoleArn");
$TimeFormat = $jResp->stringOf("Endpoint.RedshiftSettings.TimeFormat");
$TrimBlanks = $jResp->IntOf("Endpoint.RedshiftSettings.TrimBlanks");
$TruncateColumns = $jResp->IntOf("Endpoint.RedshiftSettings.TruncateColumns");
$RedshiftSettingsUsername = $jResp->stringOf("Endpoint.RedshiftSettings.Username");
$WriteBufferSize = $jResp->IntOf("Endpoint.RedshiftSettings.WriteBufferSize");
$AddColumnName = $jResp->IntOf("Endpoint.S3Settings.AddColumnName");
$S3SettingsBucketFolder = $jResp->stringOf("Endpoint.S3Settings.BucketFolder");
$S3SettingsBucketName = $jResp->stringOf("Endpoint.S3Settings.BucketName");
$CannedAclForObjects = $jResp->stringOf("Endpoint.S3Settings.CannedAclForObjects");
$CdcInsertsAndUpdates = $jResp->IntOf("Endpoint.S3Settings.CdcInsertsAndUpdates");
$CdcInsertsOnly = $jResp->IntOf("Endpoint.S3Settings.CdcInsertsOnly");
$CdcMaxBatchInterval = $jResp->IntOf("Endpoint.S3Settings.CdcMaxBatchInterval");
$CdcMinFileSize = $jResp->IntOf("Endpoint.S3Settings.CdcMinFileSize");
$CdcPath = $jResp->stringOf("Endpoint.S3Settings.CdcPath");
$CompressionType = $jResp->stringOf("Endpoint.S3Settings.CompressionType");
$CsvDelimiter = $jResp->stringOf("Endpoint.S3Settings.CsvDelimiter");
$CsvNoSupValue = $jResp->stringOf("Endpoint.S3Settings.CsvNoSupValue");
$CsvNullValue = $jResp->stringOf("Endpoint.S3Settings.CsvNullValue");
$CsvRowDelimiter = $jResp->stringOf("Endpoint.S3Settings.CsvRowDelimiter");
$DataFormat = $jResp->stringOf("Endpoint.S3Settings.DataFormat");
$DataPageSize = $jResp->IntOf("Endpoint.S3Settings.DataPageSize");
$DatePartitionDelimiter = $jResp->stringOf("Endpoint.S3Settings.DatePartitionDelimiter");
$DatePartitionEnabled = $jResp->IntOf("Endpoint.S3Settings.DatePartitionEnabled");
$DatePartitionSequence = $jResp->stringOf("Endpoint.S3Settings.DatePartitionSequence");
$DatePartitionTimezone = $jResp->stringOf("Endpoint.S3Settings.DatePartitionTimezone");
$DictPageSizeLimit = $jResp->IntOf("Endpoint.S3Settings.DictPageSizeLimit");
$EnableStatistics = $jResp->IntOf("Endpoint.S3Settings.EnableStatistics");
$EncodingType = $jResp->stringOf("Endpoint.S3Settings.EncodingType");
$S3SettingsEncryptionMode = $jResp->stringOf("Endpoint.S3Settings.EncryptionMode");
$S3SettingsExternalTableDefinition = $jResp->stringOf("Endpoint.S3Settings.ExternalTableDefinition");
$IgnoreHeaderRows = $jResp->IntOf("Endpoint.S3Settings.IgnoreHeaderRows");
$IncludeOpForFullLoad = $jResp->IntOf("Endpoint.S3Settings.IncludeOpForFullLoad");
$S3SettingsMaxFileSize = $jResp->IntOf("Endpoint.S3Settings.MaxFileSize");
$ParquetTimestampInMillisecond = $jResp->IntOf("Endpoint.S3Settings.ParquetTimestampInMillisecond");
$ParquetVersion = $jResp->stringOf("Endpoint.S3Settings.ParquetVersion");
$PreserveTransactions = $jResp->IntOf("Endpoint.S3Settings.PreserveTransactions");
$Rfc4180 = $jResp->IntOf("Endpoint.S3Settings.Rfc4180");
$RowGroupLength = $jResp->IntOf("Endpoint.S3Settings.RowGroupLength");
$S3SettingsServerSideEncryptionKmsKeyId = $jResp->stringOf("Endpoint.S3Settings.ServerSideEncryptionKmsKeyId");
$S3SettingsServiceAccessRoleArn = $jResp->stringOf("Endpoint.S3Settings.ServiceAccessRoleArn");
$TimestampColumnName = $jResp->stringOf("Endpoint.S3Settings.TimestampColumnName");
$UseCsvNoSupValue = $jResp->IntOf("Endpoint.S3Settings.UseCsvNoSupValue");
$UseTaskStartTimeForFullLoadTimestamp = $jResp->IntOf("Endpoint.S3Settings.UseTaskStartTimeForFullLoadTimestamp");
$EndpointServerName = $jResp->stringOf("Endpoint.ServerName");
$EndpointServiceAccessRoleArn = $jResp->stringOf("Endpoint.ServiceAccessRoleArn");
$SslMode = $jResp->stringOf("Endpoint.SslMode");
$Status = $jResp->stringOf("Endpoint.Status");
$SybaseSettingsDatabaseName = $jResp->stringOf("Endpoint.SybaseSettings.DatabaseName");
$SybaseSettingsPassword = $jResp->stringOf("Endpoint.SybaseSettings.Password");
$SybaseSettingsPort = $jResp->IntOf("Endpoint.SybaseSettings.Port");
$SybaseSettingsSecretsManagerAccessRoleArn = $jResp->stringOf("Endpoint.SybaseSettings.SecretsManagerAccessRoleArn");
$SybaseSettingsSecretsManagerSecretId = $jResp->stringOf("Endpoint.SybaseSettings.SecretsManagerSecretId");
$SybaseSettingsServerName = $jResp->stringOf("Endpoint.SybaseSettings.ServerName");
$SybaseSettingsUsername = $jResp->stringOf("Endpoint.SybaseSettings.Username");
$EndpointUsername = $jResp->stringOf("Endpoint.Username");
$i = 0;
$count_i = $jResp->SizeOfArray("Endpoint.OracleSettings.ExtraArchivedLogDestIds");
while ($i < $count_i) {
    $jResp->put_I($i);
    $intVal = $jResp->IntOf("Endpoint.OracleSettings.ExtraArchivedLogDestIds[i]");
    $i = $i + 1;
}

# A sample JSON response body parsed by the above code:

# {
#   "Endpoint": {
#     "CertificateArn": "string",
#     "DatabaseName": "string",
#     "DmsTransferSettings": {
#       "BucketName": "string",
#       "ServiceAccessRoleArn": "string"
#     },
#     "DocDbSettings": {
#       "DatabaseName": "string",
#       "DocsToInvestigate": number,
#       "ExtractDocId": boolean,
#       "KmsKeyId": "string",
#       "NestingLevel": "string",
#       "Password": "string",
#       "Port": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "Username": "string"
#     },
#     "DynamoDbSettings": {
#       "ServiceAccessRoleArn": "string"
#     },
#     "ElasticsearchSettings": {
#       "EndpointUri": "string",
#       "ErrorRetryDuration": number,
#       "FullLoadErrorPercentage": number,
#       "ServiceAccessRoleArn": "string"
#     },
#     "EndpointArn": "string",
#     "EndpointIdentifier": "string",
#     "EndpointType": "string",
#     "EngineDisplayName": "string",
#     "EngineName": "string",
#     "ExternalId": "string",
#     "ExternalTableDefinition": "string",
#     "ExtraConnectionAttributes": "string",
#     "GcpMySQLSettings": {
#       "AfterConnectScript": "string",
#       "CleanSourceMetadataOnMismatch": boolean,
#       "DatabaseName": "string",
#       "EventsPollInterval": number,
#       "MaxFileSize": number,
#       "ParallelLoadThreads": number,
#       "Password": "string",
#       "Port": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "ServerTimezone": "string",
#       "TargetDbType": "string",
#       "Username": "string"
#     },
#     "IBMDb2Settings": {
#       "CurrentLsn": "string",
#       "DatabaseName": "string",
#       "MaxKBytesPerRead": number,
#       "Password": "string",
#       "Port": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "SetDataCaptureChanges": boolean,
#       "Username": "string"
#     },
#     "KafkaSettings": {
#       "Broker": "string",
#       "IncludeControlDetails": boolean,
#       "IncludeNullAndEmpty": boolean,
#       "IncludePartitionValue": boolean,
#       "IncludeTableAlterOperations": boolean,
#       "IncludeTransactionDetails": boolean,
#       "MessageFormat": "string",
#       "MessageMaxBytes": number,
#       "NoHexPrefix": boolean,
#       "PartitionIncludeSchemaTable": boolean,
#       "SaslPassword": "string",
#       "SaslUsername": "string",
#       "SecurityProtocol": "string",
#       "SslCaCertificateArn": "string",
#       "SslClientCertificateArn": "string",
#       "SslClientKeyArn": "string",
#       "SslClientKeyPassword": "string",
#       "Topic": "string"
#     },
#     "KinesisSettings": {
#       "IncludeControlDetails": boolean,
#       "IncludeNullAndEmpty": boolean,
#       "IncludePartitionValue": boolean,
#       "IncludeTableAlterOperations": boolean,
#       "IncludeTransactionDetails": boolean,
#       "MessageFormat": "string",
#       "NoHexPrefix": boolean,
#       "PartitionIncludeSchemaTable": boolean,
#       "ServiceAccessRoleArn": "string",
#       "StreamArn": "string"
#     },
#     "KmsKeyId": "string",
#     "MicrosoftSQLServerSettings": {
#       "BcpPacketSize": number,
#       "ControlTablesFileGroup": "string",
#       "DatabaseName": "string",
#       "Password": "string",
#       "Port": number,
#       "QuerySingleAlwaysOnNode": boolean,
#       "ReadBackupOnly": boolean,
#       "SafeguardPolicy": "string",
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "UseBcpFullLoad": boolean,
#       "Username": "string",
#       "UseThirdPartyBackupDevice": boolean
#     },
#     "MongoDbSettings": {
#       "AuthMechanism": "string",
#       "AuthSource": "string",
#       "AuthType": "string",
#       "DatabaseName": "string",
#       "DocsToInvestigate": "string",
#       "ExtractDocId": "string",
#       "KmsKeyId": "string",
#       "NestingLevel": "string",
#       "Password": "string",
#       "Port": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "Username": "string"
#     },
#     "MySQLSettings": {
#       "AfterConnectScript": "string",
#       "CleanSourceMetadataOnMismatch": boolean,
#       "DatabaseName": "string",
#       "EventsPollInterval": number,
#       "MaxFileSize": number,
#       "ParallelLoadThreads": number,
#       "Password": "string",
#       "Port": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "ServerTimezone": "string",
#       "TargetDbType": "string",
#       "Username": "string"
#     },
#     "NeptuneSettings": {
#       "ErrorRetryDuration": number,
#       "IamAuthEnabled": boolean,
#       "MaxFileSize": number,
#       "MaxRetryCount": number,
#       "S3BucketFolder": "string",
#       "S3BucketName": "string",
#       "ServiceAccessRoleArn": "string"
#     },
#     "OracleSettings": {
#       "AccessAlternateDirectly": boolean,
#       "AdditionalArchivedLogDestId": number,
#       "AddSupplementalLogging": boolean,
#       "AllowSelectNestedTables": boolean,
#       "ArchivedLogDestId": number,
#       "ArchivedLogsOnly": boolean,
#       "AsmPassword": "string",
#       "AsmServer": "string",
#       "AsmUser": "string",
#       "CharLengthSemantics": "string",
#       "DatabaseName": "string",
#       "DirectPathNoLog": boolean,
#       "DirectPathParallelLoad": boolean,
#       "EnableHomogenousTablespace": boolean,
#       "ExtraArchivedLogDestIds": [
#         number
#       ],
#       "FailTasksOnLobTruncation": boolean,
#       "NumberDatatypeScale": number,
#       "OraclePathPrefix": "string",
#       "ParallelAsmReadThreads": number,
#       "Password": "string",
#       "Port": number,
#       "ReadAheadBlocks": number,
#       "ReadTableSpaceName": boolean,
#       "ReplacePathPrefix": boolean,
#       "RetryInterval": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerOracleAsmAccessRoleArn": "string",
#       "SecretsManagerOracleAsmSecretId": "string",
#       "SecretsManagerSecretId": "string",
#       "SecurityDbEncryption": "string",
#       "SecurityDbEncryptionName": "string",
#       "ServerName": "string",
#       "SpatialDataOptionToGeoJsonFunctionName": "string",
#       "StandbyDelayTime": number,
#       "UseAlternateFolderForOnline": boolean,
#       "UseBFile": boolean,
#       "UseDirectPathFullLoad": boolean,
#       "UseLogminerReader": boolean,
#       "UsePathPrefix": "string",
#       "Username": "string"
#     },
#     "Port": number,
#     "PostgreSQLSettings": {
#       "AfterConnectScript": "string",
#       "CaptureDdls": boolean,
#       "DatabaseName": "string",
#       "DdlArtifactsSchema": "string",
#       "ExecuteTimeout": number,
#       "FailTasksOnLobTruncation": boolean,
#       "HeartbeatEnable": boolean,
#       "HeartbeatFrequency": number,
#       "HeartbeatSchema": "string",
#       "MaxFileSize": number,
#       "Password": "string",
#       "PluginName": "string",
#       "Port": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "SlotName": "string",
#       "Username": "string"
#     },
#     "RedisSettings": {
#       "AuthPassword": "string",
#       "AuthType": "string",
#       "AuthUserName": "string",
#       "Port": number,
#       "ServerName": "string",
#       "SslCaCertificateArn": "string",
#       "SslSecurityProtocol": "string"
#     },
#     "RedshiftSettings": {
#       "AcceptAnyDate": boolean,
#       "AfterConnectScript": "string",
#       "BucketFolder": "string",
#       "BucketName": "string",
#       "CaseSensitiveNames": boolean,
#       "CompUpdate": boolean,
#       "ConnectionTimeout": number,
#       "DatabaseName": "string",
#       "DateFormat": "string",
#       "EmptyAsNull": boolean,
#       "EncryptionMode": "string",
#       "ExplicitIds": boolean,
#       "FileTransferUploadStreams": number,
#       "LoadTimeout": number,
#       "MaxFileSize": number,
#       "Password": "string",
#       "Port": number,
#       "RemoveQuotes": boolean,
#       "ReplaceChars": "string",
#       "ReplaceInvalidChars": "string",
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "ServerSideEncryptionKmsKeyId": "string",
#       "ServiceAccessRoleArn": "string",
#       "TimeFormat": "string",
#       "TrimBlanks": boolean,
#       "TruncateColumns": boolean,
#       "Username": "string",
#       "WriteBufferSize": number
#     },
#     "S3Settings": {
#       "AddColumnName": boolean,
#       "BucketFolder": "string",
#       "BucketName": "string",
#       "CannedAclForObjects": "string",
#       "CdcInsertsAndUpdates": boolean,
#       "CdcInsertsOnly": boolean,
#       "CdcMaxBatchInterval": number,
#       "CdcMinFileSize": number,
#       "CdcPath": "string",
#       "CompressionType": "string",
#       "CsvDelimiter": "string",
#       "CsvNoSupValue": "string",
#       "CsvNullValue": "string",
#       "CsvRowDelimiter": "string",
#       "DataFormat": "string",
#       "DataPageSize": number,
#       "DatePartitionDelimiter": "string",
#       "DatePartitionEnabled": boolean,
#       "DatePartitionSequence": "string",
#       "DatePartitionTimezone": "string",
#       "DictPageSizeLimit": number,
#       "EnableStatistics": boolean,
#       "EncodingType": "string",
#       "EncryptionMode": "string",
#       "ExternalTableDefinition": "string",
#       "IgnoreHeaderRows": number,
#       "IncludeOpForFullLoad": boolean,
#       "MaxFileSize": number,
#       "ParquetTimestampInMillisecond": boolean,
#       "ParquetVersion": "string",
#       "PreserveTransactions": boolean,
#       "Rfc4180": boolean,
#       "RowGroupLength": number,
#       "ServerSideEncryptionKmsKeyId": "string",
#       "ServiceAccessRoleArn": "string",
#       "TimestampColumnName": "string",
#       "UseCsvNoSupValue": boolean,
#       "UseTaskStartTimeForFullLoadTimestamp": boolean
#     },
#     "ServerName": "string",
#     "ServiceAccessRoleArn": "string",
#     "SslMode": "string",
#     "Status": "string",
#     "SybaseSettings": {
#       "DatabaseName": "string",
#       "Password": "string",
#       "Port": number,
#       "SecretsManagerAccessRoleArn": "string",
#       "SecretsManagerSecretId": "string",
#       "ServerName": "string",
#       "Username": "string"
#     },
#     "Username": "string"
#   }
# }