// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.

package shared

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/airbytehq/terraform-provider-airbyte/internal/sdk/internal/utils"
)

type SourceSapHanaEnterpriseUpdateSchemasCursorMethod string

const (
	SourceSapHanaEnterpriseUpdateSchemasCursorMethodCdc SourceSapHanaEnterpriseUpdateSchemasCursorMethod = "cdc"
)

func (e SourceSapHanaEnterpriseUpdateSchemasCursorMethod) ToPointer() *SourceSapHanaEnterpriseUpdateSchemasCursorMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateSchemasCursorMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "cdc":
		*e = SourceSapHanaEnterpriseUpdateSchemasCursorMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateSchemasCursorMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced - Determines whether Airbyte should fail or re-sync data in case of an stale/invalid cursor value in the mined logs. If 'Fail sync' is chosen, a user will have to manually reset the connection before being able to continue syncing data. If 'Re-sync data' is chosen, Airbyte will automatically trigger a refresh but could lead to higher cloud costs and data loss.
type SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced string

const (
	SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvancedFailSync   SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced = "Fail sync"
	SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvancedReSyncData SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced = "Re-sync data"
)

func (e SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced) ToPointer() *SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "Fail sync":
		fallthrough
	case "Re-sync data":
		*e = SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC - <i>Recommended</i> - Incrementally reads new inserts, updates, and deletes using change data capture feature. This must be enabled on your database.
type SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC struct {
	CursorMethod *SourceSapHanaEnterpriseUpdateSchemasCursorMethod `default:"cdc" json:"cursor_method"`
	// The amount of time an initial load is allowed to continue for before catching up on CDC events.
	InitialLoadTimeoutHours *int64 `default:"8" json:"initial_load_timeout_hours"`
	// Determines whether Airbyte should fail or re-sync data in case of an stale/invalid cursor value in the mined logs. If 'Fail sync' is chosen, a user will have to manually reset the connection before being able to continue syncing data. If 'Re-sync data' is chosen, Airbyte will automatically trigger a refresh but could lead to higher cloud costs and data loss.
	InvalidCdcCursorPositionBehavior *SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced `default:"Fail sync" json:"invalid_cdc_cursor_position_behavior"`
	AdditionalProperties             any                                                              `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC) GetCursorMethod() *SourceSapHanaEnterpriseUpdateSchemasCursorMethod {
	if o == nil {
		return nil
	}
	return o.CursorMethod
}

func (o *SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC) GetInitialLoadTimeoutHours() *int64 {
	if o == nil {
		return nil
	}
	return o.InitialLoadTimeoutHours
}

func (o *SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC) GetInvalidCdcCursorPositionBehavior() *SourceSapHanaEnterpriseUpdateInvalidCDCPositionBehaviorAdvanced {
	if o == nil {
		return nil
	}
	return o.InvalidCdcCursorPositionBehavior
}

func (o *SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

type SourceSapHanaEnterpriseUpdateCursorMethod string

const (
	SourceSapHanaEnterpriseUpdateCursorMethodUserDefined SourceSapHanaEnterpriseUpdateCursorMethod = "user_defined"
)

func (e SourceSapHanaEnterpriseUpdateCursorMethod) ToPointer() *SourceSapHanaEnterpriseUpdateCursorMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateCursorMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "user_defined":
		*e = SourceSapHanaEnterpriseUpdateCursorMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateCursorMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor - Incrementally detects new inserts and updates using the <a href="https://docs.airbyte.com/understanding-airbyte/connections/incremental-append/#user-defined-cursor">cursor column</a> chosen when configuring a connection (e.g. created_at, updated_at).
type SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor struct {
	CursorMethod         *SourceSapHanaEnterpriseUpdateCursorMethod `default:"user_defined" json:"cursor_method"`
	AdditionalProperties any                                        `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor) GetCursorMethod() *SourceSapHanaEnterpriseUpdateCursorMethod {
	if o == nil {
		return nil
	}
	return o.CursorMethod
}

func (o *SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

type SourceSapHanaEnterpriseUpdateUpdateMethodType string

const (
	SourceSapHanaEnterpriseUpdateUpdateMethodTypeSourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor     SourceSapHanaEnterpriseUpdateUpdateMethodType = "source-sap-hana-enterprise-update_Scan Changes with User Defined Cursor"
	SourceSapHanaEnterpriseUpdateUpdateMethodTypeSourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC SourceSapHanaEnterpriseUpdateUpdateMethodType = "source-sap-hana-enterprise-update_Read Changes using Change Data Capture (CDC)"
)

// SourceSapHanaEnterpriseUpdateUpdateMethod - Configures how data is extracted from the database.
type SourceSapHanaEnterpriseUpdateUpdateMethod struct {
	SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor     *SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor     `queryParam:"inline"`
	SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC *SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC `queryParam:"inline"`

	Type SourceSapHanaEnterpriseUpdateUpdateMethodType
}

func CreateSourceSapHanaEnterpriseUpdateUpdateMethodSourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor(sourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor) SourceSapHanaEnterpriseUpdateUpdateMethod {
	typ := SourceSapHanaEnterpriseUpdateUpdateMethodTypeSourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor

	return SourceSapHanaEnterpriseUpdateUpdateMethod{
		SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor: &sourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor,
		Type: typ,
	}
}

func CreateSourceSapHanaEnterpriseUpdateUpdateMethodSourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC(sourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC) SourceSapHanaEnterpriseUpdateUpdateMethod {
	typ := SourceSapHanaEnterpriseUpdateUpdateMethodTypeSourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC

	return SourceSapHanaEnterpriseUpdateUpdateMethod{
		SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC: &sourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC,
		Type: typ,
	}
}

func (u *SourceSapHanaEnterpriseUpdateUpdateMethod) UnmarshalJSON(data []byte) error {

	var sourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor = SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor = &sourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor
		u.Type = SourceSapHanaEnterpriseUpdateUpdateMethodTypeSourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor
		return nil
	}

	var sourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC = SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC = &sourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC
		u.Type = SourceSapHanaEnterpriseUpdateUpdateMethodTypeSourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC
		return nil
	}

	return fmt.Errorf("could not unmarshal `%s` into any supported union types for SourceSapHanaEnterpriseUpdateUpdateMethod", string(data))
}

func (u SourceSapHanaEnterpriseUpdateUpdateMethod) MarshalJSON() ([]byte, error) {
	if u.SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdateScanChangesWithUserDefinedCursor, "", true)
	}

	if u.SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdateReadChangesUsingChangeDataCaptureCDC, "", true)
	}

	return nil, errors.New("could not marshal union type SourceSapHanaEnterpriseUpdateUpdateMethod: all fields are null")
}

type SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod string

const (
	SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethodEncryptedVerifyCertificate SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod = "encrypted_verify_certificate"
)

func (e SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod) ToPointer() *SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "encrypted_verify_certificate":
		*e = SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate - Verify and use the certificate provided by the server.
type SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate struct {
	EncryptionMethod *SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod `default:"encrypted_verify_certificate" json:"encryption_method"`
	// Privacy Enhanced Mail (PEM) files are concatenated certificate containers frequently used in certificate installations.
	SslCertificate       string `json:"ssl_certificate"`
	AdditionalProperties any    `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate) GetEncryptionMethod() *SourceSapHanaEnterpriseUpdateSchemasEncryptionEncryptionMethod {
	if o == nil {
		return nil
	}
	return o.EncryptionMethod
}

func (o *SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate) GetSslCertificate() string {
	if o == nil {
		return ""
	}
	return o.SslCertificate
}

func (o *SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

// SourceSapHanaEnterpriseUpdateEncryptionAlgorithm - This parameter defines what encryption algorithm is used.
type SourceSapHanaEnterpriseUpdateEncryptionAlgorithm string

const (
	SourceSapHanaEnterpriseUpdateEncryptionAlgorithmAes256      SourceSapHanaEnterpriseUpdateEncryptionAlgorithm = "AES256"
	SourceSapHanaEnterpriseUpdateEncryptionAlgorithmRc456       SourceSapHanaEnterpriseUpdateEncryptionAlgorithm = "RC4_56"
	SourceSapHanaEnterpriseUpdateEncryptionAlgorithmThreeDes168 SourceSapHanaEnterpriseUpdateEncryptionAlgorithm = "3DES168"
)

func (e SourceSapHanaEnterpriseUpdateEncryptionAlgorithm) ToPointer() *SourceSapHanaEnterpriseUpdateEncryptionAlgorithm {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateEncryptionAlgorithm) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "AES256":
		fallthrough
	case "RC4_56":
		fallthrough
	case "3DES168":
		*e = SourceSapHanaEnterpriseUpdateEncryptionAlgorithm(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateEncryptionAlgorithm: %v", v)
	}
}

type SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod string

const (
	SourceSapHanaEnterpriseUpdateSchemasEncryptionMethodClientNne SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod = "client_nne"
)

func (e SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod) ToPointer() *SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "client_nne":
		*e = SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE - The native network encryption gives you the ability to encrypt database connections, without the configuration overhead of TCP/IP and SSL/TLS and without the need to open and listen on different ports.
type SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE struct {
	// This parameter defines what encryption algorithm is used.
	EncryptionAlgorithm  *SourceSapHanaEnterpriseUpdateEncryptionAlgorithm     `default:"AES256" json:"encryption_algorithm"`
	EncryptionMethod     *SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod `default:"client_nne" json:"encryption_method"`
	AdditionalProperties any                                                   `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE) GetEncryptionAlgorithm() *SourceSapHanaEnterpriseUpdateEncryptionAlgorithm {
	if o == nil {
		return nil
	}
	return o.EncryptionAlgorithm
}

func (o *SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE) GetEncryptionMethod() *SourceSapHanaEnterpriseUpdateSchemasEncryptionMethod {
	if o == nil {
		return nil
	}
	return o.EncryptionMethod
}

func (o *SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

type SourceSapHanaEnterpriseUpdateEncryptionMethod string

const (
	SourceSapHanaEnterpriseUpdateEncryptionMethodUnencrypted SourceSapHanaEnterpriseUpdateEncryptionMethod = "unencrypted"
)

func (e SourceSapHanaEnterpriseUpdateEncryptionMethod) ToPointer() *SourceSapHanaEnterpriseUpdateEncryptionMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateEncryptionMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "unencrypted":
		*e = SourceSapHanaEnterpriseUpdateEncryptionMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateEncryptionMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateUnencrypted - Data transfer will not be encrypted.
type SourceSapHanaEnterpriseUpdateUnencrypted struct {
	EncryptionMethod     *SourceSapHanaEnterpriseUpdateEncryptionMethod `default:"unencrypted" json:"encryption_method"`
	AdditionalProperties any                                            `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdateUnencrypted) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdateUnencrypted) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdateUnencrypted) GetEncryptionMethod() *SourceSapHanaEnterpriseUpdateEncryptionMethod {
	if o == nil {
		return nil
	}
	return o.EncryptionMethod
}

func (o *SourceSapHanaEnterpriseUpdateUnencrypted) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

type SourceSapHanaEnterpriseUpdateEncryptionType string

const (
	SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateUnencrypted                   SourceSapHanaEnterpriseUpdateEncryptionType = "source-sap-hana-enterprise-update_Unencrypted"
	SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE    SourceSapHanaEnterpriseUpdateEncryptionType = "source-sap-hana-enterprise-update_Native Network Encryption (NNE)"
	SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate SourceSapHanaEnterpriseUpdateEncryptionType = "source-sap-hana-enterprise-update_TLS Encrypted (verify certificate)"
)

// SourceSapHanaEnterpriseUpdateEncryption - The encryption method with is used when communicating with the database.
type SourceSapHanaEnterpriseUpdateEncryption struct {
	SourceSapHanaEnterpriseUpdateUnencrypted                   *SourceSapHanaEnterpriseUpdateUnencrypted                   `queryParam:"inline"`
	SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE    *SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE    `queryParam:"inline"`
	SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate *SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate `queryParam:"inline"`

	Type SourceSapHanaEnterpriseUpdateEncryptionType
}

func CreateSourceSapHanaEnterpriseUpdateEncryptionSourceSapHanaEnterpriseUpdateUnencrypted(sourceSapHanaEnterpriseUpdateUnencrypted SourceSapHanaEnterpriseUpdateUnencrypted) SourceSapHanaEnterpriseUpdateEncryption {
	typ := SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateUnencrypted

	return SourceSapHanaEnterpriseUpdateEncryption{
		SourceSapHanaEnterpriseUpdateUnencrypted: &sourceSapHanaEnterpriseUpdateUnencrypted,
		Type:                                     typ,
	}
}

func CreateSourceSapHanaEnterpriseUpdateEncryptionSourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE(sourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE) SourceSapHanaEnterpriseUpdateEncryption {
	typ := SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE

	return SourceSapHanaEnterpriseUpdateEncryption{
		SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE: &sourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE,
		Type: typ,
	}
}

func CreateSourceSapHanaEnterpriseUpdateEncryptionSourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate(sourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate) SourceSapHanaEnterpriseUpdateEncryption {
	typ := SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate

	return SourceSapHanaEnterpriseUpdateEncryption{
		SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate: &sourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate,
		Type: typ,
	}
}

func (u *SourceSapHanaEnterpriseUpdateEncryption) UnmarshalJSON(data []byte) error {

	var sourceSapHanaEnterpriseUpdateUnencrypted SourceSapHanaEnterpriseUpdateUnencrypted = SourceSapHanaEnterpriseUpdateUnencrypted{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdateUnencrypted, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdateUnencrypted = &sourceSapHanaEnterpriseUpdateUnencrypted
		u.Type = SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateUnencrypted
		return nil
	}

	var sourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE = SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE = &sourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE
		u.Type = SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE
		return nil
	}

	var sourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate = SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate = &sourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate
		u.Type = SourceSapHanaEnterpriseUpdateEncryptionTypeSourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate
		return nil
	}

	return fmt.Errorf("could not unmarshal `%s` into any supported union types for SourceSapHanaEnterpriseUpdateEncryption", string(data))
}

func (u SourceSapHanaEnterpriseUpdateEncryption) MarshalJSON() ([]byte, error) {
	if u.SourceSapHanaEnterpriseUpdateUnencrypted != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdateUnencrypted, "", true)
	}

	if u.SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdateNativeNetworkEncryptionNNE, "", true)
	}

	if u.SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdateTLSEncryptedVerifyCertificate, "", true)
	}

	return nil, errors.New("could not marshal union type SourceSapHanaEnterpriseUpdateEncryption: all fields are null")
}

type SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod string

const (
	SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethodSSHPasswordAuth SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod = "SSH_PASSWORD_AUTH"
)

func (e SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod) ToPointer() *SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "SSH_PASSWORD_AUTH":
		*e = SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdatePasswordAuthentication - Connect through a jump server tunnel host using username and password authentication
type SourceSapHanaEnterpriseUpdatePasswordAuthentication struct {
	// Hostname of the jump server host that allows inbound ssh tunnel.
	TunnelHost   string                                                        `json:"tunnel_host"`
	TunnelMethod *SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod `default:"SSH_PASSWORD_AUTH" json:"tunnel_method"`
	// Port on the proxy/jump server that accepts inbound ssh connections.
	TunnelPort *int64 `default:"22" json:"tunnel_port"`
	// OS-level username for logging into the jump server host
	TunnelUser string `json:"tunnel_user"`
	// OS-level password for logging into the jump server host
	TunnelUserPassword   string `json:"tunnel_user_password"`
	AdditionalProperties any    `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdatePasswordAuthentication) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdatePasswordAuthentication) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdatePasswordAuthentication) GetTunnelHost() string {
	if o == nil {
		return ""
	}
	return o.TunnelHost
}

func (o *SourceSapHanaEnterpriseUpdatePasswordAuthentication) GetTunnelMethod() *SourceSapHanaEnterpriseUpdateSchemasTunnelMethodTunnelMethod {
	if o == nil {
		return nil
	}
	return o.TunnelMethod
}

func (o *SourceSapHanaEnterpriseUpdatePasswordAuthentication) GetTunnelPort() *int64 {
	if o == nil {
		return nil
	}
	return o.TunnelPort
}

func (o *SourceSapHanaEnterpriseUpdatePasswordAuthentication) GetTunnelUser() string {
	if o == nil {
		return ""
	}
	return o.TunnelUser
}

func (o *SourceSapHanaEnterpriseUpdatePasswordAuthentication) GetTunnelUserPassword() string {
	if o == nil {
		return ""
	}
	return o.TunnelUserPassword
}

func (o *SourceSapHanaEnterpriseUpdatePasswordAuthentication) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

type SourceSapHanaEnterpriseUpdateSchemasTunnelMethod string

const (
	SourceSapHanaEnterpriseUpdateSchemasTunnelMethodSSHKeyAuth SourceSapHanaEnterpriseUpdateSchemasTunnelMethod = "SSH_KEY_AUTH"
)

func (e SourceSapHanaEnterpriseUpdateSchemasTunnelMethod) ToPointer() *SourceSapHanaEnterpriseUpdateSchemasTunnelMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateSchemasTunnelMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "SSH_KEY_AUTH":
		*e = SourceSapHanaEnterpriseUpdateSchemasTunnelMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateSchemasTunnelMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateSSHKeyAuthentication - Connect through a jump server tunnel host using username and ssh key
type SourceSapHanaEnterpriseUpdateSSHKeyAuthentication struct {
	// OS-level user account ssh key credentials in RSA PEM format ( created with ssh-keygen -t rsa -m PEM -f myuser_rsa )
	SSHKey string `json:"ssh_key"`
	// Hostname of the jump server host that allows inbound ssh tunnel.
	TunnelHost   string                                            `json:"tunnel_host"`
	TunnelMethod *SourceSapHanaEnterpriseUpdateSchemasTunnelMethod `default:"SSH_KEY_AUTH" json:"tunnel_method"`
	// Port on the proxy/jump server that accepts inbound ssh connections.
	TunnelPort *int64 `default:"22" json:"tunnel_port"`
	// OS-level username for logging into the jump server host
	TunnelUser           string `json:"tunnel_user"`
	AdditionalProperties any    `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) GetSSHKey() string {
	if o == nil {
		return ""
	}
	return o.SSHKey
}

func (o *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) GetTunnelHost() string {
	if o == nil {
		return ""
	}
	return o.TunnelHost
}

func (o *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) GetTunnelMethod() *SourceSapHanaEnterpriseUpdateSchemasTunnelMethod {
	if o == nil {
		return nil
	}
	return o.TunnelMethod
}

func (o *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) GetTunnelPort() *int64 {
	if o == nil {
		return nil
	}
	return o.TunnelPort
}

func (o *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) GetTunnelUser() string {
	if o == nil {
		return ""
	}
	return o.TunnelUser
}

func (o *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

type SourceSapHanaEnterpriseUpdateTunnelMethod string

const (
	SourceSapHanaEnterpriseUpdateTunnelMethodNoTunnel SourceSapHanaEnterpriseUpdateTunnelMethod = "NO_TUNNEL"
)

func (e SourceSapHanaEnterpriseUpdateTunnelMethod) ToPointer() *SourceSapHanaEnterpriseUpdateTunnelMethod {
	return &e
}
func (e *SourceSapHanaEnterpriseUpdateTunnelMethod) UnmarshalJSON(data []byte) error {
	var v string
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}
	switch v {
	case "NO_TUNNEL":
		*e = SourceSapHanaEnterpriseUpdateTunnelMethod(v)
		return nil
	default:
		return fmt.Errorf("invalid value for SourceSapHanaEnterpriseUpdateTunnelMethod: %v", v)
	}
}

// SourceSapHanaEnterpriseUpdateNoTunnel - No ssh tunnel needed to connect to database
type SourceSapHanaEnterpriseUpdateNoTunnel struct {
	TunnelMethod         *SourceSapHanaEnterpriseUpdateTunnelMethod `default:"NO_TUNNEL" json:"tunnel_method"`
	AdditionalProperties any                                        `additionalProperties:"true" json:"-"`
}

func (s SourceSapHanaEnterpriseUpdateNoTunnel) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdateNoTunnel) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, true); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdateNoTunnel) GetTunnelMethod() *SourceSapHanaEnterpriseUpdateTunnelMethod {
	if o == nil {
		return nil
	}
	return o.TunnelMethod
}

func (o *SourceSapHanaEnterpriseUpdateNoTunnel) GetAdditionalProperties() any {
	if o == nil {
		return nil
	}
	return o.AdditionalProperties
}

type SourceSapHanaEnterpriseUpdateSSHTunnelMethodType string

const (
	SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdateNoTunnel               SourceSapHanaEnterpriseUpdateSSHTunnelMethodType = "source-sap-hana-enterprise-update_No Tunnel"
	SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdateSSHKeyAuthentication   SourceSapHanaEnterpriseUpdateSSHTunnelMethodType = "source-sap-hana-enterprise-update_SSH Key Authentication"
	SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdatePasswordAuthentication SourceSapHanaEnterpriseUpdateSSHTunnelMethodType = "source-sap-hana-enterprise-update_Password Authentication"
)

// SourceSapHanaEnterpriseUpdateSSHTunnelMethod - Whether to initiate an SSH tunnel before connecting to the database, and if so, which kind of authentication to use.
type SourceSapHanaEnterpriseUpdateSSHTunnelMethod struct {
	SourceSapHanaEnterpriseUpdateNoTunnel               *SourceSapHanaEnterpriseUpdateNoTunnel               `queryParam:"inline"`
	SourceSapHanaEnterpriseUpdateSSHKeyAuthentication   *SourceSapHanaEnterpriseUpdateSSHKeyAuthentication   `queryParam:"inline"`
	SourceSapHanaEnterpriseUpdatePasswordAuthentication *SourceSapHanaEnterpriseUpdatePasswordAuthentication `queryParam:"inline"`

	Type SourceSapHanaEnterpriseUpdateSSHTunnelMethodType
}

func CreateSourceSapHanaEnterpriseUpdateSSHTunnelMethodSourceSapHanaEnterpriseUpdateNoTunnel(sourceSapHanaEnterpriseUpdateNoTunnel SourceSapHanaEnterpriseUpdateNoTunnel) SourceSapHanaEnterpriseUpdateSSHTunnelMethod {
	typ := SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdateNoTunnel

	return SourceSapHanaEnterpriseUpdateSSHTunnelMethod{
		SourceSapHanaEnterpriseUpdateNoTunnel: &sourceSapHanaEnterpriseUpdateNoTunnel,
		Type:                                  typ,
	}
}

func CreateSourceSapHanaEnterpriseUpdateSSHTunnelMethodSourceSapHanaEnterpriseUpdateSSHKeyAuthentication(sourceSapHanaEnterpriseUpdateSSHKeyAuthentication SourceSapHanaEnterpriseUpdateSSHKeyAuthentication) SourceSapHanaEnterpriseUpdateSSHTunnelMethod {
	typ := SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdateSSHKeyAuthentication

	return SourceSapHanaEnterpriseUpdateSSHTunnelMethod{
		SourceSapHanaEnterpriseUpdateSSHKeyAuthentication: &sourceSapHanaEnterpriseUpdateSSHKeyAuthentication,
		Type: typ,
	}
}

func CreateSourceSapHanaEnterpriseUpdateSSHTunnelMethodSourceSapHanaEnterpriseUpdatePasswordAuthentication(sourceSapHanaEnterpriseUpdatePasswordAuthentication SourceSapHanaEnterpriseUpdatePasswordAuthentication) SourceSapHanaEnterpriseUpdateSSHTunnelMethod {
	typ := SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdatePasswordAuthentication

	return SourceSapHanaEnterpriseUpdateSSHTunnelMethod{
		SourceSapHanaEnterpriseUpdatePasswordAuthentication: &sourceSapHanaEnterpriseUpdatePasswordAuthentication,
		Type: typ,
	}
}

func (u *SourceSapHanaEnterpriseUpdateSSHTunnelMethod) UnmarshalJSON(data []byte) error {

	var sourceSapHanaEnterpriseUpdateNoTunnel SourceSapHanaEnterpriseUpdateNoTunnel = SourceSapHanaEnterpriseUpdateNoTunnel{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdateNoTunnel, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdateNoTunnel = &sourceSapHanaEnterpriseUpdateNoTunnel
		u.Type = SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdateNoTunnel
		return nil
	}

	var sourceSapHanaEnterpriseUpdateSSHKeyAuthentication SourceSapHanaEnterpriseUpdateSSHKeyAuthentication = SourceSapHanaEnterpriseUpdateSSHKeyAuthentication{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdateSSHKeyAuthentication, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdateSSHKeyAuthentication = &sourceSapHanaEnterpriseUpdateSSHKeyAuthentication
		u.Type = SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdateSSHKeyAuthentication
		return nil
	}

	var sourceSapHanaEnterpriseUpdatePasswordAuthentication SourceSapHanaEnterpriseUpdatePasswordAuthentication = SourceSapHanaEnterpriseUpdatePasswordAuthentication{}
	if err := utils.UnmarshalJSON(data, &sourceSapHanaEnterpriseUpdatePasswordAuthentication, "", true, true); err == nil {
		u.SourceSapHanaEnterpriseUpdatePasswordAuthentication = &sourceSapHanaEnterpriseUpdatePasswordAuthentication
		u.Type = SourceSapHanaEnterpriseUpdateSSHTunnelMethodTypeSourceSapHanaEnterpriseUpdatePasswordAuthentication
		return nil
	}

	return fmt.Errorf("could not unmarshal `%s` into any supported union types for SourceSapHanaEnterpriseUpdateSSHTunnelMethod", string(data))
}

func (u SourceSapHanaEnterpriseUpdateSSHTunnelMethod) MarshalJSON() ([]byte, error) {
	if u.SourceSapHanaEnterpriseUpdateNoTunnel != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdateNoTunnel, "", true)
	}

	if u.SourceSapHanaEnterpriseUpdateSSHKeyAuthentication != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdateSSHKeyAuthentication, "", true)
	}

	if u.SourceSapHanaEnterpriseUpdatePasswordAuthentication != nil {
		return utils.MarshalJSON(u.SourceSapHanaEnterpriseUpdatePasswordAuthentication, "", true)
	}

	return nil, errors.New("could not marshal union type SourceSapHanaEnterpriseUpdateSSHTunnelMethod: all fields are null")
}

type SourceSapHanaEnterpriseUpdate struct {
	// When this feature is enabled, during schema discovery the connector will query each table or view individually to check access privileges and inaccessible tables, views, or columns therein will be removed. In large schemas, this might cause schema discovery to take too long, in which case it might be advisable to disable this feature.
	CheckPrivileges *bool `default:"true" json:"check_privileges"`
	// How often (in seconds) a stream should checkpoint, when possible.
	CheckpointTargetIntervalSeconds *int64 `default:"300" json:"checkpoint_target_interval_seconds"`
	// Maximum number of concurrent queries to the database.
	Concurrency *int64 `default:"1" json:"concurrency"`
	// Configures how data is extracted from the database.
	Cursor SourceSapHanaEnterpriseUpdateUpdateMethod `json:"cursor"`
	// The encryption method with is used when communicating with the database.
	Encryption SourceSapHanaEnterpriseUpdateEncryption `json:"encryption"`
	// Hostname of the database.
	Host string `json:"host"`
	// Additional properties to pass to the JDBC URL string when connecting to the database formatted as 'key=value' pairs separated by the symbol '&'. (example: key1=value1&key2=value2&key3=value3).
	JdbcURLParams *string `json:"jdbc_url_params,omitempty"`
	// The password associated with the username.
	Password *string `json:"password,omitempty"`
	// Port of the database.
	// SapHana Corporations recommends the following port numbers:
	// 443 - Default listening port for SAP HANA cloud client connections to the listener.
	Port *int64 `default:"443" json:"port"`
	// The list of schemas to sync from. Defaults to user. Case sensitive.
	Schemas []string `json:"schemas,omitempty"`
	// Whether to initiate an SSH tunnel before connecting to the database, and if so, which kind of authentication to use.
	TunnelMethod SourceSapHanaEnterpriseUpdateSSHTunnelMethod `json:"tunnel_method"`
	// The username which is used to access the database.
	Username string `json:"username"`
}

func (s SourceSapHanaEnterpriseUpdate) MarshalJSON() ([]byte, error) {
	return utils.MarshalJSON(s, "", false)
}

func (s *SourceSapHanaEnterpriseUpdate) UnmarshalJSON(data []byte) error {
	if err := utils.UnmarshalJSON(data, &s, "", false, false); err != nil {
		return err
	}
	return nil
}

func (o *SourceSapHanaEnterpriseUpdate) GetCheckPrivileges() *bool {
	if o == nil {
		return nil
	}
	return o.CheckPrivileges
}

func (o *SourceSapHanaEnterpriseUpdate) GetCheckpointTargetIntervalSeconds() *int64 {
	if o == nil {
		return nil
	}
	return o.CheckpointTargetIntervalSeconds
}

func (o *SourceSapHanaEnterpriseUpdate) GetConcurrency() *int64 {
	if o == nil {
		return nil
	}
	return o.Concurrency
}

func (o *SourceSapHanaEnterpriseUpdate) GetCursor() SourceSapHanaEnterpriseUpdateUpdateMethod {
	if o == nil {
		return SourceSapHanaEnterpriseUpdateUpdateMethod{}
	}
	return o.Cursor
}

func (o *SourceSapHanaEnterpriseUpdate) GetEncryption() SourceSapHanaEnterpriseUpdateEncryption {
	if o == nil {
		return SourceSapHanaEnterpriseUpdateEncryption{}
	}
	return o.Encryption
}

func (o *SourceSapHanaEnterpriseUpdate) GetHost() string {
	if o == nil {
		return ""
	}
	return o.Host
}

func (o *SourceSapHanaEnterpriseUpdate) GetJdbcURLParams() *string {
	if o == nil {
		return nil
	}
	return o.JdbcURLParams
}

func (o *SourceSapHanaEnterpriseUpdate) GetPassword() *string {
	if o == nil {
		return nil
	}
	return o.Password
}

func (o *SourceSapHanaEnterpriseUpdate) GetPort() *int64 {
	if o == nil {
		return nil
	}
	return o.Port
}

func (o *SourceSapHanaEnterpriseUpdate) GetSchemas() []string {
	if o == nil {
		return nil
	}
	return o.Schemas
}

func (o *SourceSapHanaEnterpriseUpdate) GetTunnelMethod() SourceSapHanaEnterpriseUpdateSSHTunnelMethod {
	if o == nil {
		return SourceSapHanaEnterpriseUpdateSSHTunnelMethod{}
	}
	return o.TunnelMethod
}

func (o *SourceSapHanaEnterpriseUpdate) GetUsername() string {
	if o == nil {
		return ""
	}
	return o.Username
}
