full-tkh-to-tf-ds.go

// Code generated by "terraform-provider-keyhub-generator"; DO NOT EDIT.
// Copyright (c) Topicus Security B.V.
// SPDX-License-Identifier: APSL-2.0

//lint:ignore U1000 Ignore unused functions in generated code
package provider

import (
	"golang.org/x/exp/maps"

	"github.com/hashicorp/terraform-plugin-framework/attr"
	"github.com/hashicorp/terraform-plugin-framework/diag"
	"github.com/hashicorp/terraform-plugin-framework/types"
	keyhubmodel "github.com/topicuskeyhub/sdk-go/models"
)

func tkhToTFObjectDSAuditInfo(recurse bool, tkh keyhubmodel.AuditInfoable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = auditInfoAttrTypesDSRecurse
	} else {
		attrs = auditInfoAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["created_at"] = timePointerToTF(tkh.GetCreatedAt())
	obj["created_by"] = types.StringPointerValue(tkh.GetCreatedBy())
	obj["last_modified_at"] = timePointerToTF(tkh.GetLastModifiedAt())
	obj["last_modified_by"] = types.StringPointerValue(tkh.GetLastModifiedBy())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGeneratedSecret(recurse bool, tkh keyhubmodel.GeneratedSecretable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = generatedSecretAttrTypesDSRecurse
	} else {
		attrs = generatedSecretAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["generated_secret"] = types.StringPointerValue(tkh.GetGeneratedSecret())
	obj["old_secret"] = types.StringPointerValue(tkh.GetOldSecret())
	obj["regenerate"] = types.BoolPointerValue(tkh.GetRegenerate())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSLinkable(recurse bool, tkh keyhubmodel.Linkableable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = linkableAttrTypesDSRecurse
	} else {
		attrs = linkableAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSNonLinkable(recurse bool, tkh keyhubmodel.NonLinkableable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = nonLinkableAttrTypesDSRecurse
	} else {
		attrs = nonLinkableAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSRestLink(recurse bool, tkh keyhubmodel.RestLinkable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = restLinkAttrTypesDSRecurse
	} else {
		attrs = restLinkAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["href"] = types.StringPointerValue(tkh.GetHref())
	obj["id"] = types.Int64PointerValue(tkh.GetId())
	obj["rel"] = types.StringPointerValue(tkh.GetRel())
	obj["type_escaped"] = types.StringPointerValue(tkh.GetTypeEscaped())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthAccount(recurse bool, tkh keyhubmodel.AuthAccountable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authAccountAttrTypesDSRecurse
	} else {
		attrs = authAccountAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSAuthAccount_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["last_active"] = timePointerToTF(tkh.GetLastActive())
	obj["username"] = types.StringPointerValue(tkh.GetUsername())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["validity"] = stringerToTF(tkh.GetValidity())
	{
		elemType := attrs["account_permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetAccountPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(false, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["account_permissions"] = val
	}
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["can_request_groups"] = types.BoolPointerValue(tkh.GetCanRequestGroups())
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryPrimer(false, tkh.GetDirectory())
		diags.Append(d...)
		obj["directory"] = val
	}
	obj["directory_name"] = types.StringPointerValue(tkh.GetDirectoryName())
	obj["directory_password_change_required"] = types.BoolPointerValue(tkh.GetDirectoryPasswordChangeRequired())
	obj["directory_rotating_password"] = stringerToTF(tkh.GetDirectoryRotatingPassword())
	obj["directory_type"] = stringerToTF(tkh.GetDirectoryType())
	obj["email"] = types.StringPointerValue(tkh.GetEmail())
	obj["id_in_directory"] = types.StringPointerValue(tkh.GetIdInDirectory())
	obj["key_hub_password_change_required"] = types.BoolPointerValue(tkh.GetKeyHubPasswordChangeRequired())
	obj["last_modified_at"] = timePointerToTF(tkh.GetLastModifiedAt())
	obj["license_role"] = stringerToTF(tkh.GetLicenseRole())
	obj["locale"] = types.StringPointerValue(tkh.GetLocale())
	obj["reregistration_required"] = types.BoolPointerValue(tkh.GetReregistrationRequired())
	obj["token_password_enabled"] = types.BoolPointerValue(tkh.GetTokenPasswordEnabled())
	obj["two_factor_status"] = stringerToTF(tkh.GetTwoFactorStatus())
	obj["valid_in_directory"] = types.BoolPointerValue(tkh.GetValidInDirectory())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthAccountPrimer(recurse bool, tkh keyhubmodel.AuthAccountPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authAccountPrimerAttrTypesDSRecurse
	} else {
		attrs = authAccountPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["last_active"] = timePointerToTF(tkh.GetLastActive())
	obj["username"] = types.StringPointerValue(tkh.GetUsername())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["validity"] = stringerToTF(tkh.GetValidity())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthAccountRecoveryStatus(recurse bool, tkh keyhubmodel.AuthAccountRecoveryStatusable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authAccountRecoveryStatusAttrTypesDSRecurse
	} else {
		attrs = authAccountRecoveryStatusAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["pending2fa_recovery_request"] = types.BoolPointerValue(tkh.GetPending2FARecoveryRequest())
	obj["pending_password_recovery_request"] = types.BoolPointerValue(tkh.GetPendingPasswordRecoveryRequest())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthAccountSettings(recurse bool, tkh keyhubmodel.AuthAccountSettingsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authAccountSettingsAttrTypesDSRecurse
	} else {
		attrs = authAccountSettingsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(recurse, tkh.GetDefaultOrganizationalUnit())
		diags.Append(d...)
		obj["default_organizational_unit"] = val
	}
	obj["directory_name"] = types.StringPointerValue(tkh.GetDirectoryName())
	obj["directory_type"] = stringerToTF(tkh.GetDirectoryType())
	obj["in_groups"] = types.BoolPointerValue(tkh.GetInGroups())
	obj["in_multiple_organizational_units"] = types.BoolPointerValue(tkh.GetInMultipleOrganizationalUnits())
	obj["key_hub_admin"] = types.BoolPointerValue(tkh.GetKeyHubAdmin())
	obj["multiple_organizational_units_exist"] = types.BoolPointerValue(tkh.GetMultipleOrganizationalUnitsExist())
	obj["password_mode"] = stringerToTF(tkh.GetPasswordMode())
	obj["ssh_public_key"] = types.StringPointerValue(tkh.GetSshPublicKey())
	obj["two_factor_authentication"] = stringerToTF(tkh.GetTwoFactorAuthentication())
	obj["use_token_password"] = types.BoolPointerValue(tkh.GetUseTokenPassword())
	obj["vault_status"] = stringerToTF(tkh.GetVaultStatus())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthAccount_additionalObjects(recurse bool, tkh keyhubmodel.AuthAccount_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authAccount_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = authAccount_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["active_login"] = types.BoolPointerValue(tkh.GetActiveLogin())
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupAccountGroupLinkableWrapper(recurse, tkh.GetGroups())
		diags.Append(d...)
		obj["groups"] = getItemsAttr(val, attrs["groups"])
	}
	{
		val, d := tkhToTFObjectDSAuthAccountRecoveryStatus(recurse, tkh.GetPendingRecoveryRequests())
		diags.Append(d...)
		obj["pending_recovery_requests"] = val
	}
	{
		val, d := tkhToTFObjectDSAuthAccountSettings(recurse, tkh.GetSettings())
		diags.Append(d...)
		obj["settings"] = val
	}
	{
		val, d := tkhToTFObjectDSAuthStoredAccountAttributes(recurse, tkh.GetStoredAttributes())
		diags.Append(d...)
		obj["stored_attributes"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVault(recurse, tkh.GetVault())
		diags.Append(d...)
		obj["vault"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthPermission(recurse bool, tkh keyhubmodel.AuthPermissionable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authPermissionAttrTypesDSRecurse
	} else {
		attrs = authPermissionAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["full"] = types.StringPointerValue(tkh.GetFull())
	{
		elemType := attrs["instances"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetInstances(), func(tkh string, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh)
		})
		diags.Append(d...)
		obj["instances"] = val
	}
	{
		elemType := attrs["operations"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetOperations(), func(tkh keyhubmodel.AuthPermittedOperation, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.String())
		})
		diags.Append(d...)
		obj["operations"] = val
	}
	obj["type_escaped"] = types.StringPointerValue(tkh.GetTypeEscaped())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthStoredAccountAttribute(recurse bool, tkh keyhubmodel.AuthStoredAccountAttributeable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authStoredAccountAttributeAttrTypesDSRecurse
	} else {
		attrs = authStoredAccountAttributeAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["value"] = types.StringPointerValue(tkh.GetValue())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSAuthStoredAccountAttributes(recurse bool, tkh keyhubmodel.AuthStoredAccountAttributesable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = authStoredAccountAttributesAttrTypesDSRecurse
	} else {
		attrs = authStoredAccountAttributesAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["attributes"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetAttributes(), func(tkh keyhubmodel.AuthStoredAccountAttributeable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthStoredAccountAttribute(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["attributes"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSCertificateCertificate(recurse bool, tkh keyhubmodel.CertificateCertificateable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = certificateCertificateAttrTypesDSRecurse
	} else {
		attrs = certificateCertificateAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSCertificateCertificate_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["alias"] = types.StringPointerValue(tkh.GetAlias())
	obj["type"] = stringerToTF(tkh.GetCertificateCertificatePrimerType())
	obj["certificate_data"] = types.StringPointerValue(tkh.GetCertificateData())
	obj["expiration"] = timePointerToTF(tkh.GetExpiration())
	obj["fingerprint_sha1"] = types.StringPointerValue(tkh.GetFingerprintSha1())
	obj["fingerprint_sha256"] = types.StringPointerValue(tkh.GetFingerprintSha256())
	obj["global"] = types.BoolPointerValue(tkh.GetGlobal())
	obj["subject_dn"] = types.StringPointerValue(tkh.GetSubjectDN())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["key_data"] = types.StringPointerValue(tkh.GetKeyData())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSCertificateCertificatePrimer(recurse bool, tkh keyhubmodel.CertificateCertificatePrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = certificateCertificatePrimerAttrTypesDSRecurse
	} else {
		attrs = certificateCertificatePrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["alias"] = types.StringPointerValue(tkh.GetAlias())
	obj["type"] = stringerToTF(tkh.GetCertificateCertificatePrimerType())
	obj["certificate_data"] = types.StringPointerValue(tkh.GetCertificateData())
	obj["expiration"] = timePointerToTF(tkh.GetExpiration())
	obj["fingerprint_sha1"] = types.StringPointerValue(tkh.GetFingerprintSha1())
	obj["fingerprint_sha256"] = types.StringPointerValue(tkh.GetFingerprintSha256())
	obj["global"] = types.BoolPointerValue(tkh.GetGlobal())
	obj["subject_dn"] = types.StringPointerValue(tkh.GetSubjectDN())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSCertificateCertificate_additionalObjects(recurse bool, tkh keyhubmodel.CertificateCertificate_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = certificateCertificate_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = certificateCertificate_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientClientApplication(recurse bool, tkh keyhubmodel.ClientClientApplicationable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientClientApplicationAttrTypesDSRecurse
	} else {
		attrs = clientClientApplicationAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSClientClientApplication_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["type"] = stringerToTF(tkh.GetClientClientApplicationPrimerType())
	obj["client_id"] = types.StringPointerValue(tkh.GetClientId())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		elemType := attrs["scopes"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetScopes(), func(tkh string, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh)
		})
		diags.Append(d...)
		obj["scopes"] = val
	}
	obj["sso_application"] = types.BoolPointerValue(tkh.GetSsoApplication())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["last_modified_at"] = timePointerToTF(tkh.GetLastModifiedAt())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetOwner())
		diags.Append(d...)
		obj["owner"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetTechnicalAdministrator())
		diags.Append(d...)
		obj["technical_administrator"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ClientLdapClientable)
		val, d := tkhToTFObjectDSClientLdapClient(false, tkhCast)
		diags.Append(d...)
		obj["ldap_client"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ClientOAuth2Clientable)
		val, d := tkhToTFObjectDSClientOAuth2Client(false, tkhCast)
		diags.Append(d...)
		obj["o_auth2_client"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ClientSaml2Clientable)
		val, d := tkhToTFObjectDSClientSaml2Client(false, tkhCast)
		diags.Append(d...)
		obj["saml2_client"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientClientApplicationLinkableWrapper(recurse bool, tkh keyhubmodel.ClientClientApplicationLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientClientApplicationLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = clientClientApplicationLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ClientClientApplicationable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSClientClientApplication(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientClientApplicationPrimer(recurse bool, tkh keyhubmodel.ClientClientApplicationPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientClientApplicationPrimerAttrTypesDSRecurse
	} else {
		attrs = clientClientApplicationPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["type"] = stringerToTF(tkh.GetClientClientApplicationPrimerType())
	obj["client_id"] = types.StringPointerValue(tkh.GetClientId())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		elemType := attrs["scopes"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetScopes(), func(tkh string, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh)
		})
		diags.Append(d...)
		obj["scopes"] = val
	}
	obj["sso_application"] = types.BoolPointerValue(tkh.GetSsoApplication())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientClientApplication_additionalObjects(recurse bool, tkh keyhubmodel.ClientClientApplication_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientClientApplication_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = clientClientApplication_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupClientLinkableWrapper(recurse, tkh.GetGroupclients())
		diags.Append(d...)
		obj["groupclients"] = getItemsAttr(val, attrs["groupclients"])
	}
	{
		val, d := tkhToTFObjectDSGroupGroupLinkableWrapper(recurse, tkh.GetGroups())
		diags.Append(d...)
		obj["groups"] = getItemsAttr(val, attrs["groups"])
	}
	{
		val, d := tkhToTFObjectDSGeneratedSecret(recurse, tkh.GetSecret())
		diags.Append(d...)
		obj["secret"] = val
	}
	{
		val, d := tkhToTFObjectDSLaunchpadSsoApplicationLaunchpadTile(recurse, tkh.GetTile())
		diags.Append(d...)
		obj["tile"] = val
	}
	obj["vault_record_count"] = types.Int64PointerValue(int32PToInt64P(tkh.GetVaultRecordCount()))

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientLdapClient(recurse bool, tkh keyhubmodel.ClientLdapClientable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientLdapClientAttrTypesDSRecurse
	} else {
		attrs = clientLdapClientAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["bind_dn"] = types.StringPointerValue(tkh.GetBindDn())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(recurse, tkh.GetClientCertificate())
		diags.Append(d...)
		obj["client_certificate"] = val
	}
	obj["share_secret_in_vault"] = types.BoolPointerValue(tkh.GetShareSecretInVault())
	{
		val, d := tkhToTFObjectDSVaultVaultRecordPrimer(recurse, tkh.GetSharedSecret())
		diags.Append(d...)
		obj["shared_secret"] = val
	}
	obj["used_for_provisioning"] = types.BoolPointerValue(tkh.GetUsedForProvisioning())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientOAuth2Client(recurse bool, tkh keyhubmodel.ClientOAuth2Clientable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientOAuth2ClientAttrTypesDSRecurse
	} else {
		attrs = clientOAuth2ClientAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["account_permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetAccountPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["account_permissions"] = val
	}
	{
		elemType := attrs["attributes"].(types.MapType).ElemType
		val, d := mapToTF(elemType, tkh.GetAttributes().GetAdditionalData(), func(tkh any, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.(string))
		})
		diags.Append(d...)
		obj["attributes"] = val
	}
	obj["callback_uri"] = types.StringPointerValue(tkh.GetCallbackURI())
	obj["confidential"] = types.BoolPointerValue(tkh.GetConfidential())
	obj["debug_mode"] = types.BoolPointerValue(tkh.GetDebugMode())
	obj["id_token_claims"] = types.StringPointerValue(tkh.GetIdTokenClaims())
	obj["initiate_login_uri"] = types.StringPointerValue(tkh.GetInitiateLoginURI())
	obj["resource_uris"] = types.StringPointerValue(tkh.GetResourceURIs())
	obj["share_secret_in_vault"] = types.BoolPointerValue(tkh.GetShareSecretInVault())
	{
		val, d := tkhToTFObjectDSVaultVaultRecordPrimer(recurse, tkh.GetSharedSecret())
		diags.Append(d...)
		obj["shared_secret"] = val
	}
	obj["show_landing_page"] = types.BoolPointerValue(tkh.GetShowLandingPage())
	obj["use_client_credentials"] = types.BoolPointerValue(tkh.GetUseClientCredentials())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientOAuth2ClientPermission(recurse bool, tkh keyhubmodel.ClientOAuth2ClientPermissionable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientOAuth2ClientPermissionAttrTypesDSRecurse
	} else {
		attrs = clientOAuth2ClientPermissionAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSClientOAuth2ClientPermission_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetForGroup())
		diags.Append(d...)
		obj["for_group"] = val
	}
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimer(false, tkh.GetForSystem())
		diags.Append(d...)
		obj["for_system"] = val
	}
	obj["value"] = stringerToTF(tkh.GetValue())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientOAuth2ClientPermissionWithClient(recurse bool, tkh keyhubmodel.ClientOAuth2ClientPermissionWithClientable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientOAuth2ClientPermissionWithClientAttrTypesDSRecurse
	} else {
		attrs = clientOAuth2ClientPermissionWithClientAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSClientOAuth2ClientPermission_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetForGroup())
		diags.Append(d...)
		obj["for_group"] = val
	}
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimer(false, tkh.GetForSystem())
		diags.Append(d...)
		obj["for_system"] = val
	}
	obj["value"] = stringerToTF(tkh.GetValue())
	{
		val, d := tkhToTFObjectDSClientOAuth2Client(false, tkh.GetClient())
		diags.Append(d...)
		obj["client"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientOAuth2ClientPermissionWithClientLinkableWrapper(recurse bool, tkh keyhubmodel.ClientOAuth2ClientPermissionWithClientLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientOAuth2ClientPermissionWithClientLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = clientOAuth2ClientPermissionWithClientLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ClientOAuth2ClientPermissionWithClientable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSClientOAuth2ClientPermissionWithClient(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientOAuth2ClientPermission_additionalObjects(recurse bool, tkh keyhubmodel.ClientOAuth2ClientPermission_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientOAuth2ClientPermission_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = clientOAuth2ClientPermission_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSClientSaml2Client(recurse bool, tkh keyhubmodel.ClientSaml2Clientable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = clientSaml2ClientAttrTypesDSRecurse
	} else {
		attrs = clientSaml2ClientAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["attributes"].(types.MapType).ElemType
		val, d := mapToTF(elemType, tkh.GetAttributes().GetAdditionalData(), func(tkh any, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.(string))
		})
		diags.Append(d...)
		obj["attributes"] = val
	}
	obj["metadata"] = types.StringPointerValue(tkh.GetMetadata())
	obj["metadata_url"] = types.StringPointerValue(tkh.GetMetadataUrl())
	obj["subject_format"] = stringerToTF(tkh.GetSubjectFormat())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryAccountDirectory(recurse bool, tkh keyhubmodel.DirectoryAccountDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryAccountDirectoryAttrTypesDSRecurse
	} else {
		attrs = directoryAccountDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSDirectoryAccountDirectory_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["account_validity_supported"] = types.BoolPointerValue(tkh.GetAccountValiditySupported())
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["type"] = stringerToTF(tkh.GetDirectoryAccountDirectoryPrimerType())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(false, tkh.GetBaseOrganizationalUnit())
		diags.Append(d...)
		obj["base_organizational_unit"] = val
	}
	obj["default_directory"] = types.BoolPointerValue(tkh.GetDefaultDirectory())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetHelpdeskGroup())
		diags.Append(d...)
		obj["helpdesk_group"] = val
	}
	obj["restrict2fa"] = types.BoolPointerValue(tkh.GetRestrict2fa())
	obj["rotating_password"] = stringerToTF(tkh.GetRotatingPassword())
	obj["username_customizable"] = types.BoolPointerValue(tkh.GetUsernameCustomizable())
	{
		tkhCast, _ := tkh.(keyhubmodel.DirectoryInternalDirectoryable)
		val, d := tkhToTFObjectDSDirectoryInternalDirectory(false, tkhCast)
		diags.Append(d...)
		obj["internal_directory"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.DirectoryLDAPDirectoryable)
		val, d := tkhToTFObjectDSDirectoryLDAPDirectory(false, tkhCast)
		diags.Append(d...)
		obj["l_d_a_p_directory"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.DirectoryMaintenanceDirectoryable)
		val, d := tkhToTFObjectDSDirectoryMaintenanceDirectory(false, tkhCast)
		diags.Append(d...)
		obj["maintenance_directory"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.DirectoryOIDCDirectoryable)
		val, d := tkhToTFObjectDSDirectoryOIDCDirectory(false, tkhCast)
		diags.Append(d...)
		obj["o_id_c_directory"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryAccountDirectoryLinkableWrapper(recurse bool, tkh keyhubmodel.DirectoryAccountDirectoryLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryAccountDirectoryLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = directoryAccountDirectoryLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.DirectoryAccountDirectoryable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSDirectoryAccountDirectory(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryAccountDirectoryPrimer(recurse bool, tkh keyhubmodel.DirectoryAccountDirectoryPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryAccountDirectoryPrimerAttrTypesDSRecurse
	} else {
		attrs = directoryAccountDirectoryPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["account_validity_supported"] = types.BoolPointerValue(tkh.GetAccountValiditySupported())
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["type"] = stringerToTF(tkh.GetDirectoryAccountDirectoryPrimerType())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryAccountDirectoryStatusReport(recurse bool, tkh keyhubmodel.DirectoryAccountDirectoryStatusReportable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryAccountDirectoryStatusReportAttrTypesDSRecurse
	} else {
		attrs = directoryAccountDirectoryStatusReportAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["accounts"] = types.Int64PointerValue(tkh.GetAccounts())
	obj["reason"] = types.StringPointerValue(tkh.GetReason())
	obj["status"] = stringerToTF(tkh.GetStatus())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryAccountDirectorySummary(recurse bool, tkh keyhubmodel.DirectoryAccountDirectorySummaryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryAccountDirectorySummaryAttrTypesDSRecurse
	} else {
		attrs = directoryAccountDirectorySummaryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["type"] = stringerToTF(tkh.GetDirectoryAccountDirectorySummaryType())
	obj["domain_restriction"] = types.StringPointerValue(tkh.GetDomainRestriction())
	obj["fully_resolved_issuer"] = types.StringPointerValue(tkh.GetFullyResolvedIssuer())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryStatusReport(recurse, tkh.GetStatus())
		diags.Append(d...)
		obj["status"] = val
	}
	obj["username_customizable"] = types.BoolPointerValue(tkh.GetUsernameCustomizable())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryAccountDirectorySummaryLinkableWrapper(recurse bool, tkh keyhubmodel.DirectoryAccountDirectorySummaryLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryAccountDirectorySummaryLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = directoryAccountDirectorySummaryLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.DirectoryAccountDirectorySummaryable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSDirectoryAccountDirectorySummary(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryAccountDirectory_additionalObjects(recurse bool, tkh keyhubmodel.DirectoryAccountDirectory_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryAccountDirectory_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = directoryAccountDirectory_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSMarkItemMarkers(recurse, tkh.GetMarkers())
		diags.Append(d...)
		obj["markers"] = val
	}
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryStatusReport(recurse, tkh.GetStatus())
		diags.Append(d...)
		obj["status"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryInternalDirectory(recurse bool, tkh keyhubmodel.DirectoryInternalDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryInternalDirectoryAttrTypesDSRecurse
	} else {
		attrs = directoryInternalDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(recurse, tkh.GetOwner())
		diags.Append(d...)
		obj["owner"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryLDAPDirectory(recurse bool, tkh keyhubmodel.DirectoryLDAPDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryLDAPDirectoryAttrTypesDSRecurse
	} else {
		attrs = directoryLDAPDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["attributes_to_store"] = types.StringPointerValue(tkh.GetAttributesToStore())
	obj["base_dn"] = types.StringPointerValue(tkh.GetBaseDN())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(recurse, tkh.GetClientCertificate())
		diags.Append(d...)
		obj["client_certificate"] = val
	}
	obj["dialect"] = stringerToTF(tkh.GetDialect())
	obj["failover_host"] = types.StringPointerValue(tkh.GetFailoverHost())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(recurse, tkh.GetFailoverTrustedCertificate())
		diags.Append(d...)
		obj["failover_trusted_certificate"] = val
	}
	obj["host"] = types.StringPointerValue(tkh.GetHost())
	obj["password_recovery"] = stringerToTF(tkh.GetPasswordRecovery())
	obj["port"] = types.Int64PointerValue(int32PToInt64P(tkh.GetPort()))
	obj["search_bind_dn"] = types.StringPointerValue(tkh.GetSearchBindDN())
	obj["search_bind_password"] = types.StringPointerValue(tkh.GetSearchBindPassword())
	obj["search_filter"] = types.StringPointerValue(tkh.GetSearchFilter())
	obj["tls"] = stringerToTF(tkh.GetTls())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(recurse, tkh.GetTrustedCertificate())
		diags.Append(d...)
		obj["trusted_certificate"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryMaintenanceDirectory(recurse bool, tkh keyhubmodel.DirectoryMaintenanceDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryMaintenanceDirectoryAttrTypesDSRecurse
	} else {
		attrs = directoryMaintenanceDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSDirectoryOIDCDirectory(recurse bool, tkh keyhubmodel.DirectoryOIDCDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = directoryOIDCDirectoryAttrTypesDSRecurse
	} else {
		attrs = directoryOIDCDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["acr_values"] = types.StringPointerValue(tkh.GetAcrValues())
	obj["attributes_to_store"] = types.StringPointerValue(tkh.GetAttributesToStore())
	obj["client_id"] = types.StringPointerValue(tkh.GetClientId())
	obj["client_secret"] = types.StringPointerValue(tkh.GetClientSecret())
	obj["domain_restriction"] = types.StringPointerValue(tkh.GetDomainRestriction())
	obj["enforces2fa"] = types.BoolPointerValue(tkh.GetEnforces2fa())
	obj["fully_resolved_issuer"] = types.StringPointerValue(tkh.GetFullyResolvedIssuer())
	obj["issuer"] = types.StringPointerValue(tkh.GetIssuer())
	obj["logout_url"] = types.StringPointerValue(tkh.GetLogoutUrl())
	obj["send_login_hint"] = types.BoolPointerValue(tkh.GetSendLoginHint())
	obj["vendor_escaped"] = stringerToTF(tkh.GetVendorEscaped())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupAccountGroup(recurse bool, tkh keyhubmodel.GroupAccountGroupable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupAccountGroupAttrTypesDSRecurse
	} else {
		attrs = groupAccountGroupAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupAccountGroup_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["admin"] = types.BoolPointerValue(tkh.GetAdmin())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(recurse, tkh.GetOrganizationalUnit())
		diags.Append(d...)
		obj["organizational_unit"] = val
	}
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["end_date"] = stringerToTF(tkh.GetEndDate())
	{
		val, d := tkhToTFObjectDSGroupGroupFolder(false, tkh.GetFolder())
		diags.Append(d...)
		obj["folder"] = val
	}
	obj["last_used"] = stringerToTF(tkh.GetLastUsed())
	obj["provisioning_end_time"] = timePointerToTF(tkh.GetProvisioningEndTime())
	obj["rights"] = stringerToTF(tkh.GetRights())
	obj["visible_for_provisioning"] = types.BoolPointerValue(tkh.GetVisibleForProvisioning())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupAccountGroupLinkableWrapper(recurse bool, tkh keyhubmodel.GroupAccountGroupLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupAccountGroupLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = groupAccountGroupLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupAccountGroupable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupAccountGroup(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupAccountGroup_additionalObjects(recurse bool, tkh keyhubmodel.GroupAccountGroup_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupAccountGroup_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupAccountGroup_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVault(recurse, tkh.GetVault())
		diags.Append(d...)
		obj["vault"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupAuthorizedGroupsWrapper(recurse bool, tkh keyhubmodel.GroupAuthorizedGroupsWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupAuthorizedGroupsWrapperAttrTypesDSRecurse
	} else {
		attrs = groupAuthorizedGroupsWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupGroupable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupGroup(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}
	obj["group_count"] = types.Int64PointerValue(tkh.GetGroupCount())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroup(recurse bool, tkh keyhubmodel.GroupGroupable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAttrTypesDSRecurse
	} else {
		attrs = groupGroupAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupGroup_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["admin"] = types.BoolPointerValue(tkh.GetAdmin())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(recurse, tkh.GetOrganizationalUnit())
		diags.Append(d...)
		obj["organizational_unit"] = val
	}
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["application_administration"] = types.BoolPointerValue(tkh.GetApplicationAdministration())
	{
		val, d := tkhToTFObjectDSGroupGroupAuditConfig(false, tkh.GetAuditConfig())
		diags.Append(d...)
		obj["audit_config"] = val
	}
	obj["audit_requested"] = types.BoolPointerValue(tkh.GetAuditRequested())
	obj["auditor"] = types.BoolPointerValue(tkh.GetAuditor())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetAuthorizingGroupAuditing())
		diags.Append(d...)
		obj["authorizing_group_auditing"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetAuthorizingGroupDelegation())
		diags.Append(d...)
		obj["authorizing_group_delegation"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetAuthorizingGroupMembership())
		diags.Append(d...)
		obj["authorizing_group_membership"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetAuthorizingGroupProvisioning())
		diags.Append(d...)
		obj["authorizing_group_provisioning"] = val
	}
	{
		elemType := attrs["authorizing_group_types"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetAuthorizingGroupTypes(), func(tkh keyhubmodel.RequestAuthorizingGroupType, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.String())
		})
		diags.Append(d...)
		obj["authorizing_group_types"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupClassificationPrimer(false, tkh.GetClassification())
		diags.Append(d...)
		obj["classification"] = val
	}
	obj["description"] = types.StringPointerValue(tkh.GetDescription())
	obj["extended_access"] = stringerToTF(tkh.GetExtendedAccess())
	obj["hide_audit_trail"] = types.BoolPointerValue(tkh.GetHideAuditTrail())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetNestedUnder())
		diags.Append(d...)
		obj["nested_under"] = val
	}
	obj["private_group"] = types.BoolPointerValue(tkh.GetPrivateGroup())
	obj["record_trail"] = types.BoolPointerValue(tkh.GetRecordTrail())
	obj["rotating_password_required"] = types.BoolPointerValue(tkh.GetRotatingPasswordRequired())
	obj["single_managed"] = types.BoolPointerValue(tkh.GetSingleManaged())
	obj["vault_recovery"] = stringerToTF(tkh.GetVaultRecovery())
	obj["vault_requires_activation"] = types.BoolPointerValue(tkh.GetVaultRequiresActivation())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAccount(recurse bool, tkh keyhubmodel.GroupGroupAccountable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAccountAttrTypesDSRecurse
	} else {
		attrs = groupGroupAccountAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupGroupAccount_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["last_active"] = timePointerToTF(tkh.GetLastActive())
	obj["username"] = types.StringPointerValue(tkh.GetUsername())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["validity"] = stringerToTF(tkh.GetValidity())
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryPrimer(false, tkh.GetDirectory())
		diags.Append(d...)
		obj["directory"] = val
	}
	obj["disconnected_nested"] = types.BoolPointerValue(tkh.GetDisconnectedNested())
	obj["end_date"] = stringerToTF(tkh.GetEndDate())
	obj["last_used"] = stringerToTF(tkh.GetLastUsed())
	obj["nested"] = types.BoolPointerValue(tkh.GetNested())
	obj["provisioning_end_time"] = timePointerToTF(tkh.GetProvisioningEndTime())
	obj["rights"] = stringerToTF(tkh.GetRights())
	obj["two_factor_status"] = stringerToTF(tkh.GetTwoFactorStatus())
	obj["visible_for_provisioning"] = types.BoolPointerValue(tkh.GetVisibleForProvisioning())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAccountLinkableWrapper(recurse bool, tkh keyhubmodel.GroupGroupAccountLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAccountLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = groupGroupAccountLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupGroupAccountable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupGroupAccount(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAccount_additionalObjects(recurse bool, tkh keyhubmodel.GroupGroupAccount_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAccount_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupGroupAccount_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAudit(recurse bool, tkh keyhubmodel.GroupGroupAuditable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAuditAttrTypesDSRecurse
	} else {
		attrs = groupGroupAuditAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupGroupAudit_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	{
		elemType := attrs["accounts"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetAccounts(), func(tkh keyhubmodel.GroupGroupAuditAccountable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupGroupAuditAccount(false, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["accounts"] = val
	}
	obj["comment"] = types.StringPointerValue(tkh.GetComment())
	obj["created_at"] = timePointerToTF(tkh.GetCreatedAt())
	obj["created_by"] = types.StringPointerValue(tkh.GetCreatedBy())
	obj["group_name"] = types.StringPointerValue(tkh.GetGroupName())
	obj["name_on_audit"] = types.StringPointerValue(tkh.GetNameOnAudit())
	obj["reviewed_at"] = timePointerToTF(tkh.GetReviewedAt())
	obj["reviewed_by"] = types.StringPointerValue(tkh.GetReviewedBy())
	obj["status"] = stringerToTF(tkh.GetStatus())
	obj["submitted_at"] = timePointerToTF(tkh.GetSubmittedAt())
	obj["submitted_by"] = types.StringPointerValue(tkh.GetSubmittedBy())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAuditAccount(recurse bool, tkh keyhubmodel.GroupGroupAuditAccountable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAuditAccountAttrTypesDSRecurse
	} else {
		attrs = groupGroupAuditAccountAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["account_uuid"] = types.StringPointerValue(tkh.GetAccountUuid())
	obj["account_valid"] = types.BoolPointerValue(tkh.GetAccountValid())
	obj["action"] = stringerToTF(tkh.GetAction())
	obj["comment"] = types.StringPointerValue(tkh.GetComment())
	obj["disconnected_nested"] = types.BoolPointerValue(tkh.GetDisconnectedNested())
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["end_date"] = stringerToTF(tkh.GetEndDate())
	obj["last_active"] = timePointerToTF(tkh.GetLastActive())
	obj["last_used"] = stringerToTF(tkh.GetLastUsed())
	obj["nested"] = types.BoolPointerValue(tkh.GetNested())
	obj["rights"] = stringerToTF(tkh.GetRights())
	obj["username"] = types.StringPointerValue(tkh.GetUsername())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAuditConfig(recurse bool, tkh keyhubmodel.GroupGroupAuditConfigable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAuditConfigAttrTypesDSRecurse
	} else {
		attrs = groupGroupAuditConfigAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	{
		elemType := attrs["months"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetMonths(), func(tkh keyhubmodel.Month, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.String())
		})
		diags.Append(d...)
		obj["months"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAuditLinkableWrapper(recurse bool, tkh keyhubmodel.GroupGroupAuditLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAuditLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = groupGroupAuditLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupGroupAuditable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupGroupAudit(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAudit_additionalObjects(recurse bool, tkh keyhubmodel.GroupGroupAudit_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAudit_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupGroupAudit_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupAuditingInfo(recurse bool, tkh keyhubmodel.GroupGroupAuditingInfoable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupAuditingInfoAttrTypesDSRecurse
	} else {
		attrs = groupGroupAuditingInfoAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["audit_due_date"] = stringerToTF(tkh.GetAuditDueDate())
	obj["last_audit_date"] = stringerToTF(tkh.GetLastAuditDate())
	obj["nr_accounts"] = types.Int64PointerValue(tkh.GetNrAccounts())
	obj["nr_disabled_accounts"] = types.Int64PointerValue(tkh.GetNrDisabledAccounts())
	obj["nr_disabled_managers"] = types.Int64PointerValue(tkh.GetNrDisabledManagers())
	obj["nr_expired_vault_records"] = types.Int64PointerValue(tkh.GetNrExpiredVaultRecords())
	obj["nr_managers"] = types.Int64PointerValue(tkh.GetNrManagers())
	obj["nr_vault_records_with_end_date"] = types.Int64PointerValue(tkh.GetNrVaultRecordsWithEndDate())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupClassification(recurse bool, tkh keyhubmodel.GroupGroupClassificationable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupClassificationAttrTypesDSRecurse
	} else {
		attrs = groupGroupClassificationAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupGroupClassification_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["authorizing_group_auditing_required"] = types.BoolPointerValue(tkh.GetAuthorizingGroupAuditingRequired())
	obj["authorizing_group_delegation_required"] = types.BoolPointerValue(tkh.GetAuthorizingGroupDelegationRequired())
	obj["authorizing_group_membership_required"] = types.BoolPointerValue(tkh.GetAuthorizingGroupMembershipRequired())
	obj["authorizing_group_provisioning_required"] = types.BoolPointerValue(tkh.GetAuthorizingGroupProvisioningRequired())
	obj["default_classification"] = types.BoolPointerValue(tkh.GetDefaultClassification())
	obj["description"] = types.StringPointerValue(tkh.GetDescription())
	obj["maximum_audit_interval"] = types.Int64PointerValue(int32PToInt64P(tkh.GetMaximumAuditInterval()))
	obj["minimum_nr_managers"] = types.Int64PointerValue(int32PToInt64P(tkh.GetMinimumNrManagers()))
	obj["record_trail_required"] = types.BoolPointerValue(tkh.GetRecordTrailRequired())
	{
		elemType := attrs["required_months"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetRequiredMonths(), func(tkh keyhubmodel.Month, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.String())
		})
		diags.Append(d...)
		obj["required_months"] = val
	}
	obj["rotating_password_required"] = types.BoolPointerValue(tkh.GetRotatingPasswordRequired())
	obj["vault_requires_activation"] = types.BoolPointerValue(tkh.GetVaultRequiresActivation())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupClassificationInfo(recurse bool, tkh keyhubmodel.GroupGroupClassificationInfoable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupClassificationInfoAttrTypesDSRecurse
	} else {
		attrs = groupGroupClassificationInfoAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["nr_groups"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNrGroups()))

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupClassificationPrimer(recurse bool, tkh keyhubmodel.GroupGroupClassificationPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupClassificationPrimerAttrTypesDSRecurse
	} else {
		attrs = groupGroupClassificationPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupClassification_additionalObjects(recurse bool, tkh keyhubmodel.GroupGroupClassification_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupClassification_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupGroupClassification_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupClassificationInfo(recurse, tkh.GetInfo())
		diags.Append(d...)
		obj["info"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupClient(recurse bool, tkh keyhubmodel.GroupGroupClientable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupClientAttrTypesDSRecurse
	} else {
		attrs = groupGroupClientAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupGroupClient_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["activation_required"] = types.BoolPointerValue(tkh.GetActivationRequired())
	{
		val, d := tkhToTFObjectDSClientClientApplicationPrimer(false, tkh.GetClient())
		diags.Append(d...)
		obj["client"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetGroup())
		diags.Append(d...)
		obj["group"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetOwner())
		diags.Append(d...)
		obj["owner"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetTechnicalAdministrator())
		diags.Append(d...)
		obj["technical_administrator"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupClientLinkableWrapper(recurse bool, tkh keyhubmodel.GroupGroupClientLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupClientLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = groupGroupClientLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupGroupClientable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupGroupClient(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupClient_additionalObjects(recurse bool, tkh keyhubmodel.GroupGroupClient_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupClient_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupGroupClient_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupFolder(recurse bool, tkh keyhubmodel.GroupGroupFolderable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupFolderAttrTypesDSRecurse
	} else {
		attrs = groupGroupFolderAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupGroupFolder_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["name"] = types.StringPointerValue(tkh.GetName())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupFolder_additionalObjects(recurse bool, tkh keyhubmodel.GroupGroupFolder_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupFolder_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupGroupFolder_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupInfo(recurse bool, tkh keyhubmodel.GroupGroupInfoable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupInfoAttrTypesDSRecurse
	} else {
		attrs = groupGroupInfoAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["nr_accounts"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNrAccounts()))
	obj["nr_accounts_with_vault"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNrAccountsWithVault()))
	obj["nr_audits"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNrAudits()))
	obj["nr_clients"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNrClients()))
	obj["nr_provisioned_systems"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNrProvisionedSystems()))
	obj["nr_vault_records"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNrVaultRecords()))

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupLinkableWrapper(recurse bool, tkh keyhubmodel.GroupGroupLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = groupGroupLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupGroupable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupGroup(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupPrimer(recurse bool, tkh keyhubmodel.GroupGroupPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupPrimerAttrTypesDSRecurse
	} else {
		attrs = groupGroupPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["admin"] = types.BoolPointerValue(tkh.GetAdmin())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(recurse, tkh.GetOrganizationalUnit())
		diags.Append(d...)
		obj["organizational_unit"] = val
	}
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroupPrimerLinkableWrapper(recurse bool, tkh keyhubmodel.GroupGroupPrimerLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroupPrimerLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = groupGroupPrimerLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupGroupPrimerable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupGroupPrimer(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupGroup_additionalObjects(recurse bool, tkh keyhubmodel.GroupGroup_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupGroup_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupGroup_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSGroupGroupAccountLinkableWrapper(recurse, tkh.GetAccounts())
		diags.Append(d...)
		obj["accounts"] = getItemsAttr(val, attrs["accounts"])
	}
	{
		val, d := tkhToTFObjectDSClientClientApplicationLinkableWrapper(recurse, tkh.GetAdministeredClients())
		diags.Append(d...)
		obj["administered_clients"] = getItemsAttr(val, attrs["administered_clients"])
	}
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemLinkableWrapper(recurse, tkh.GetAdministeredSystems())
		diags.Append(d...)
		obj["administered_systems"] = getItemsAttr(val, attrs["administered_systems"])
	}
	{
		val, d := tkhToTFObjectDSGroupGroupAccountLinkableWrapper(recurse, tkh.GetAdmins())
		diags.Append(d...)
		obj["admins"] = getItemsAttr(val, attrs["admins"])
	}
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupAuthorizedGroupsWrapper(recurse, tkh.GetAuthorizedGroups())
		diags.Append(d...)
		obj["authorized_groups"] = val
	}
	{
		val, d := tkhToTFObjectDSClientOAuth2ClientPermissionWithClientLinkableWrapper(recurse, tkh.GetClientPermissions())
		diags.Append(d...)
		obj["client_permissions"] = getItemsAttr(val, attrs["client_permissions"])
	}
	{
		val, d := tkhToTFObjectDSGroupGroupClientLinkableWrapper(recurse, tkh.GetClients())
		diags.Append(d...)
		obj["clients"] = getItemsAttr(val, attrs["clients"])
	}
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemLinkableWrapper(recurse, tkh.GetContentAdministeredSystems())
		diags.Append(d...)
		obj["content_administered_systems"] = getItemsAttr(val, attrs["content_administered_systems"])
	}
	{
		val, d := tkhToTFObjectDSGroupGroupAuditingInfo(recurse, tkh.GetGroupauditinginfo())
		diags.Append(d...)
		obj["groupauditinginfo"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupInfo(recurse, tkh.GetGroupinfo())
		diags.Append(d...)
		obj["groupinfo"] = val
	}
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectorySummaryLinkableWrapper(recurse, tkh.GetHelpdesk())
		diags.Append(d...)
		obj["helpdesk"] = getItemsAttr(val, attrs["helpdesk"])
	}
	{
		val, d := tkhToTFObjectDSMarkItemMarkers(recurse, tkh.GetMarkers())
		diags.Append(d...)
		obj["markers"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupAccount(recurse, tkh.GetMyaccount())
		diags.Append(d...)
		obj["myaccount"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupAccount(recurse, tkh.GetMydelegatedaccount())
		diags.Append(d...)
		obj["mydelegatedaccount"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimerLinkableWrapper(recurse, tkh.GetNestedGroups())
		diags.Append(d...)
		obj["nested_groups"] = getItemsAttr(val, attrs["nested_groups"])
	}
	{
		val, d := tkhToTFObjectDSClientClientApplicationLinkableWrapper(recurse, tkh.GetOwnedClients())
		diags.Append(d...)
		obj["owned_clients"] = getItemsAttr(val, attrs["owned_clients"])
	}
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryLinkableWrapper(recurse, tkh.GetOwnedDirectories())
		diags.Append(d...)
		obj["owned_directories"] = getItemsAttr(val, attrs["owned_directories"])
	}
	{
		val, d := tkhToTFObjectDSProvisioningOwnedGroupOnSystemsWrapper(recurse, tkh.GetOwnedGroupsOnSystem())
		diags.Append(d...)
		obj["owned_groups_on_system"] = val
	}
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitLinkableWrapper(recurse, tkh.GetOwnedOrganizationalUnits())
		diags.Append(d...)
		obj["owned_organizational_units"] = getItemsAttr(val, attrs["owned_organizational_units"])
	}
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemLinkableWrapper(recurse, tkh.GetOwnedSystems())
		diags.Append(d...)
		obj["owned_systems"] = getItemsAttr(val, attrs["owned_systems"])
	}
	{
		val, d := tkhToTFObjectDSGroupGroupAuditLinkableWrapper(recurse, tkh.GetRecentAudits())
		diags.Append(d...)
		obj["recent_audits"] = getItemsAttr(val, attrs["recent_audits"])
	}
	obj["requeststatus"] = stringerToTF(tkh.GetRequeststatus())
	{
		val, d := tkhToTFObjectDSServiceaccountServiceAccountLinkableWrapper(recurse, tkh.GetServiceAccounts())
		diags.Append(d...)
		obj["service_accounts"] = getItemsAttr(val, attrs["service_accounts"])
	}
	{
		val, d := tkhToTFObjectDSGroupProvisioningGroupLinkableWrapper(recurse, tkh.GetSystems())
		diags.Append(d...)
		obj["systems"] = getItemsAttr(val, attrs["systems"])
	}
	{
		val, d := tkhToTFObjectDSVaultVault(recurse, tkh.GetVault())
		diags.Append(d...)
		obj["vault"] = val
	}
	{
		val, d := tkhToTFObjectDSWebhookWebhookLinkableWrapper(recurse, tkh.GetWebhooks())
		diags.Append(d...)
		obj["webhooks"] = getItemsAttr(val, attrs["webhooks"])
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupProvisioningGroup(recurse bool, tkh keyhubmodel.GroupProvisioningGroupable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupProvisioningGroupAttrTypesDSRecurse
	} else {
		attrs = groupProvisioningGroupAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSGroupProvisioningGroup_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["activation_required"] = types.BoolPointerValue(tkh.GetActivationRequired())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetGroup())
		diags.Append(d...)
		obj["group"] = val
	}
	{
		val, d := tkhToTFObjectDSProvisioningGroupOnSystem(false, tkh.GetGroupOnSystem())
		diags.Append(d...)
		obj["group_on_system"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupProvisioningGroupLinkableWrapper(recurse bool, tkh keyhubmodel.GroupProvisioningGroupLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupProvisioningGroupLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = groupProvisioningGroupLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.GroupProvisioningGroupable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSGroupProvisioningGroup(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSGroupProvisioningGroup_additionalObjects(recurse bool, tkh keyhubmodel.GroupProvisioningGroup_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = groupProvisioningGroup_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = groupProvisioningGroup_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSLaunchpadSsoApplicationLaunchpadTile(recurse bool, tkh keyhubmodel.LaunchpadSsoApplicationLaunchpadTileable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = launchpadSsoApplicationLaunchpadTileAttrTypesDSRecurse
	} else {
		attrs = launchpadSsoApplicationLaunchpadTileAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["uri"] = types.StringPointerValue(tkh.GetUri())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSLaunchpadVaultRecordLaunchpadTile(recurse bool, tkh keyhubmodel.LaunchpadVaultRecordLaunchpadTileable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = launchpadVaultRecordLaunchpadTileAttrTypesDSRecurse
	} else {
		attrs = launchpadVaultRecordLaunchpadTileAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSMarkItemMarker(recurse bool, tkh keyhubmodel.MarkItemMarkerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = markItemMarkerAttrTypesDSRecurse
	} else {
		attrs = markItemMarkerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["level"] = stringerToTF(tkh.GetLevel())
	obj["type"] = stringerToTF(tkh.GetMarkItemMarkerType())
	{
		elemType := attrs["parameters"].(types.MapType).ElemType
		val, d := mapToTF(elemType, tkh.GetParameters().GetAdditionalData(), func(tkh any, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.(string))
		})
		diags.Append(d...)
		obj["parameters"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSMarkItemMarkers(recurse bool, tkh keyhubmodel.MarkItemMarkersable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = markItemMarkersAttrTypesDSRecurse
	} else {
		attrs = markItemMarkersAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["markers"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetMarkers(), func(tkh keyhubmodel.MarkItemMarkerable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSMarkItemMarker(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["markers"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSOrganizationOrganizationalUnit(recurse bool, tkh keyhubmodel.OrganizationOrganizationalUnitable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = organizationOrganizationalUnitAttrTypesDSRecurse
	} else {
		attrs = organizationOrganizationalUnitAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSOrganizationOrganizationalUnit_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["depth"] = types.Int64PointerValue(int32PToInt64P(tkh.GetDepth()))
	obj["description"] = types.StringPointerValue(tkh.GetDescription())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetOwner())
		diags.Append(d...)
		obj["owner"] = val
	}
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(false, tkh.GetParent())
		diags.Append(d...)
		obj["parent"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSOrganizationOrganizationalUnitLinkableWrapper(recurse bool, tkh keyhubmodel.OrganizationOrganizationalUnitLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = organizationOrganizationalUnitLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = organizationOrganizationalUnitLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.OrganizationOrganizationalUnitable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSOrganizationOrganizationalUnit(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(recurse bool, tkh keyhubmodel.OrganizationOrganizationalUnitPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = organizationOrganizationalUnitPrimerAttrTypesDSRecurse
	} else {
		attrs = organizationOrganizationalUnitPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSOrganizationOrganizationalUnit_additionalObjects(recurse bool, tkh keyhubmodel.OrganizationOrganizationalUnit_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = organizationOrganizationalUnit_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = organizationOrganizationalUnit_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningAbstractProvisionedLDAP(recurse bool, tkh keyhubmodel.ProvisioningAbstractProvisionedLDAPable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningAbstractProvisionedLDAPAttrTypesDSRecurse
	} else {
		attrs = provisioningAbstractProvisionedLDAPAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["attributes"].(types.MapType).ElemType
		val, d := mapToTF(elemType, tkh.GetAttributes().GetAdditionalData(), func(tkh any, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.(string))
		})
		diags.Append(d...)
		obj["attributes"] = val
	}
	obj["base_dn"] = types.StringPointerValue(tkh.GetBaseDN())
	obj["bind_dn"] = types.StringPointerValue(tkh.GetBindDN())
	obj["bind_password"] = types.StringPointerValue(tkh.GetBindPassword())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(recurse, tkh.GetClientCertificate())
		diags.Append(d...)
		obj["client_certificate"] = val
	}
	obj["failover_host"] = types.StringPointerValue(tkh.GetFailoverHost())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(recurse, tkh.GetFailoverTrustedCertificate())
		diags.Append(d...)
		obj["failover_trusted_certificate"] = val
	}
	obj["group_dn"] = types.StringPointerValue(tkh.GetGroupDN())
	obj["host"] = types.StringPointerValue(tkh.GetHost())
	obj["object_classes"] = types.StringPointerValue(tkh.GetObjectClasses())
	obj["port"] = types.Int64PointerValue(int32PToInt64P(tkh.GetPort()))
	obj["service_account_dn"] = types.StringPointerValue(tkh.GetServiceAccountDN())
	obj["ssh_public_key_supported"] = types.BoolPointerValue(tkh.GetSshPublicKeySupported())
	obj["tls"] = stringerToTF(tkh.GetTls())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(recurse, tkh.GetTrustedCertificate())
		diags.Append(d...)
		obj["trusted_certificate"] = val
	}
	obj["user_dn"] = types.StringPointerValue(tkh.GetUserDN())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningCircuitBreakerStatistics(recurse bool, tkh keyhubmodel.ProvisioningCircuitBreakerStatisticsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningCircuitBreakerStatisticsAttrTypesDSRecurse
	} else {
		attrs = provisioningCircuitBreakerStatisticsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["number_of_failed_calls"] = types.Int64PointerValue(tkh.GetNumberOfFailedCalls())
	obj["number_of_not_permitted_calls"] = types.Int64PointerValue(tkh.GetNumberOfNotPermittedCalls())
	obj["number_of_successful_calls"] = types.Int64PointerValue(tkh.GetNumberOfSuccessfulCalls())
	obj["state"] = stringerToTF(tkh.GetState())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningGroupOnSystem(recurse bool, tkh keyhubmodel.ProvisioningGroupOnSystemable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningGroupOnSystemAttrTypesDSRecurse
	} else {
		attrs = provisioningGroupOnSystemAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSProvisioningGroupOnSystem_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["name_in_system"] = types.StringPointerValue(tkh.GetNameInSystem())
	obj["type"] = stringerToTF(tkh.GetProvisioningGroupOnSystemPrimerType())
	obj["short_name_in_system"] = types.StringPointerValue(tkh.GetShortNameInSystem())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetOwner())
		diags.Append(d...)
		obj["owner"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningGroupOnSystemLinkableWrapper(recurse bool, tkh keyhubmodel.ProvisioningGroupOnSystemLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningGroupOnSystemLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = provisioningGroupOnSystemLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ProvisioningGroupOnSystemable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSProvisioningGroupOnSystem(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningGroupOnSystemPrimer(recurse bool, tkh keyhubmodel.ProvisioningGroupOnSystemPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningGroupOnSystemPrimerAttrTypesDSRecurse
	} else {
		attrs = provisioningGroupOnSystemPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["name_in_system"] = types.StringPointerValue(tkh.GetNameInSystem())
	obj["type"] = stringerToTF(tkh.GetProvisioningGroupOnSystemPrimerType())
	obj["short_name_in_system"] = types.StringPointerValue(tkh.GetShortNameInSystem())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningGroupOnSystemTypes(recurse bool, tkh keyhubmodel.ProvisioningGroupOnSystemTypesable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningGroupOnSystemTypesAttrTypesDSRecurse
	} else {
		attrs = provisioningGroupOnSystemTypesAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["types"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetTypes(), func(tkh keyhubmodel.ProvisioningGroupOnSystemType, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.String())
		})
		diags.Append(d...)
		obj["types"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningGroupOnSystem_additionalObjects(recurse bool, tkh keyhubmodel.ProvisioningGroupOnSystem_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningGroupOnSystem_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = provisioningGroupOnSystem_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupProvisioningGroupLinkableWrapper(recurse, tkh.GetProvgroups())
		diags.Append(d...)
		obj["provgroups"] = getItemsAttr(val, attrs["provgroups"])
	}
	{
		val, d := tkhToTFObjectDSServiceaccountServiceAccountPrimerLinkableWrapper(recurse, tkh.GetServiceAccounts())
		diags.Append(d...)
		obj["service_accounts"] = getItemsAttr(val, attrs["service_accounts"])
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningOwnedGroupOnSystemsWrapper(recurse bool, tkh keyhubmodel.ProvisioningOwnedGroupOnSystemsWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningOwnedGroupOnSystemsWrapperAttrTypesDSRecurse
	} else {
		attrs = provisioningOwnedGroupOnSystemsWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ProvisioningGroupOnSystemable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSProvisioningGroupOnSystem(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}
	obj["unlinked_count"] = types.Int64PointerValue(tkh.GetUnlinkedCount())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionNumberSequence(recurse bool, tkh keyhubmodel.ProvisioningProvisionNumberSequenceable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionNumberSequenceAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionNumberSequenceAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSProvisioningProvisionNumberSequence_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["account_count"] = types.Int64PointerValue(int32PToInt64P(tkh.GetAccountCount()))
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["next_uid"] = types.Int64PointerValue(tkh.GetNextUID())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionNumberSequence_additionalObjects(recurse bool, tkh keyhubmodel.ProvisioningProvisionNumberSequence_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionNumberSequence_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionNumberSequence_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimerLinkableWrapper(recurse, tkh.GetSystems())
		diags.Append(d...)
		obj["systems"] = getItemsAttr(val, attrs["systems"])
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedAD(recurse bool, tkh keyhubmodel.ProvisioningProvisionedADable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedADAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedADAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["sam_account_name_scheme"] = stringerToTF(tkh.GetSamAccountNameScheme())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedAccount(recurse bool, tkh keyhubmodel.ProvisioningProvisionedAccountable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedAccountAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedAccountAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSProvisioningProvisionedAccount_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["last_active"] = timePointerToTF(tkh.GetLastActive())
	obj["username"] = types.StringPointerValue(tkh.GetUsername())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["validity"] = stringerToTF(tkh.GetValidity())
	obj["uid"] = types.Int64PointerValue(tkh.GetUid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedAccount_additionalObjects(recurse bool, tkh keyhubmodel.ProvisioningProvisionedAccount_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedAccount_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedAccount_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedAzureOIDCDirectory(recurse bool, tkh keyhubmodel.ProvisioningProvisionedAzureOIDCDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedAzureOIDCDirectoryAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedAzureOIDCDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryPrimer(recurse, tkh.GetDirectory())
		diags.Append(d...)
		obj["directory"] = val
	}
	obj["tenant"] = types.StringPointerValue(tkh.GetTenant())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedAzureSyncLDAPDirectory(recurse bool, tkh keyhubmodel.ProvisioningProvisionedAzureSyncLDAPDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedAzureSyncLDAPDirectoryAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedAzureSyncLDAPDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["client_id"] = types.StringPointerValue(tkh.GetClientId())
	obj["client_secret"] = types.StringPointerValue(tkh.GetClientSecret())
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryPrimer(recurse, tkh.GetDirectory())
		diags.Append(d...)
		obj["directory"] = val
	}
	obj["tenant"] = types.StringPointerValue(tkh.GetTenant())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedAzureTenant(recurse bool, tkh keyhubmodel.ProvisioningProvisionedAzureTenantable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedAzureTenantAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedAzureTenantAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["client_id"] = types.StringPointerValue(tkh.GetClientId())
	obj["client_secret"] = types.StringPointerValue(tkh.GetClientSecret())
	obj["idp_domain"] = types.StringPointerValue(tkh.GetIdpDomain())
	obj["tenant"] = types.StringPointerValue(tkh.GetTenant())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedInternalLDAP(recurse bool, tkh keyhubmodel.ProvisioningProvisionedInternalLDAPable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedInternalLDAPAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedInternalLDAPAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSClientLdapClient(recurse, tkh.GetClient())
		diags.Append(d...)
		obj["client"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedLDAP(recurse bool, tkh keyhubmodel.ProvisioningProvisionedLDAPable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedLDAPAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedLDAPAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["gid"] = types.Int64PointerValue(tkh.GetGid())
	obj["hashing_scheme"] = stringerToTF(tkh.GetHashingScheme())
	{
		val, d := tkhToTFObjectDSProvisioningProvisionNumberSequence(recurse, tkh.GetNumbering())
		diags.Append(d...)
		obj["numbering"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedLDAPDirectory(recurse bool, tkh keyhubmodel.ProvisioningProvisionedLDAPDirectoryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedLDAPDirectoryAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedLDAPDirectoryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryPrimer(recurse, tkh.GetDirectory())
		diags.Append(d...)
		obj["directory"] = val
	}
	obj["group_dn"] = types.StringPointerValue(tkh.GetGroupDN())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedNamespace(recurse bool, tkh keyhubmodel.ProvisioningProvisionedNamespaceable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedNamespaceAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedNamespaceAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimer(recurse, tkh.GetBaseSystem())
		diags.Append(d...)
		obj["base_system"] = val
	}
	obj["group_dn"] = types.StringPointerValue(tkh.GetGroupDN())
	obj["service_account_dn"] = types.StringPointerValue(tkh.GetServiceAccountDN())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedSCIM(recurse bool, tkh keyhubmodel.ProvisioningProvisionedSCIMable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedSCIMAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedSCIMAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["authentication_scheme"] = stringerToTF(tkh.GetAuthenticationScheme())
	obj["basic_auth_password"] = types.StringPointerValue(tkh.GetBasicAuthPassword())
	obj["basic_auth_username"] = types.StringPointerValue(tkh.GetBasicAuthUsername())
	obj["bearer_token"] = types.StringPointerValue(tkh.GetBearerToken())
	obj["custom_header_name"] = types.StringPointerValue(tkh.GetCustomHeaderName())
	obj["custom_header_value"] = types.StringPointerValue(tkh.GetCustomHeaderValue())
	obj["url"] = types.StringPointerValue(tkh.GetUrl())
	obj["vendor_escaped"] = stringerToTF(tkh.GetVendorEscaped())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedSystem(recurse bool, tkh keyhubmodel.ProvisioningProvisionedSystemable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedSystemAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedSystemAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSProvisioningProvisionedSystem_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(recurse, tkh.GetOrganizationalUnit())
		diags.Append(d...)
		obj["organizational_unit"] = val
	}
	obj["type"] = stringerToTF(tkh.GetProvisioningProvisionedSystemPrimerType())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["account_count"] = types.Int64PointerValue(int32PToInt64P(tkh.GetAccountCount()))
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetContentAdministrator())
		diags.Append(d...)
		obj["content_administrator"] = val
	}
	obj["external_uuid"] = stringerToTF(tkh.GetExternalUuid())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetOwner())
		diags.Append(d...)
		obj["owner"] = val
	}
	obj["self_service_existing_groups"] = types.BoolPointerValue(tkh.GetSelfServiceExistingGroups())
	obj["self_service_new_groups"] = types.BoolPointerValue(tkh.GetSelfServiceNewGroups())
	obj["self_service_new_namespaces"] = types.BoolPointerValue(tkh.GetSelfServiceNewNamespaces())
	obj["self_service_service_accounts"] = types.BoolPointerValue(tkh.GetSelfServiceServiceAccounts())
	obj["should_destroy_unknown_accounts"] = types.BoolPointerValue(tkh.GetShouldDestroyUnknownAccounts())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetTechnicalAdministrator())
		diags.Append(d...)
		obj["technical_administrator"] = val
	}
	obj["username_prefix"] = types.StringPointerValue(tkh.GetUsernamePrefix())
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningAbstractProvisionedLDAPable)
		val, d := tkhToTFObjectDSProvisioningAbstractProvisionedLDAP(false, tkhCast)
		diags.Append(d...)
		obj["abstract_provisioned_ldap"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedADable)
		val, d := tkhToTFObjectDSProvisioningProvisionedAD(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_a_d"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedAzureOIDCDirectoryable)
		val, d := tkhToTFObjectDSProvisioningProvisionedAzureOIDCDirectory(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_azure_oidc_directory"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedAzureSyncLDAPDirectoryable)
		val, d := tkhToTFObjectDSProvisioningProvisionedAzureSyncLDAPDirectory(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_azure_sync_ldap_directory"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedAzureTenantable)
		val, d := tkhToTFObjectDSProvisioningProvisionedAzureTenant(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_azure_tenant"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedInternalLDAPable)
		val, d := tkhToTFObjectDSProvisioningProvisionedInternalLDAP(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_internal_ldap"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedLDAPable)
		val, d := tkhToTFObjectDSProvisioningProvisionedLDAP(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_ldap"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedLDAPDirectoryable)
		val, d := tkhToTFObjectDSProvisioningProvisionedLDAPDirectory(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_ldap_directory"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedNamespaceable)
		val, d := tkhToTFObjectDSProvisioningProvisionedNamespace(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_namespace"] = val
	}
	{
		tkhCast, _ := tkh.(keyhubmodel.ProvisioningProvisionedSCIMable)
		val, d := tkhToTFObjectDSProvisioningProvisionedSCIM(false, tkhCast)
		diags.Append(d...)
		obj["provisioned_scim"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedSystemLinkableWrapper(recurse bool, tkh keyhubmodel.ProvisioningProvisionedSystemLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedSystemLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedSystemLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ProvisioningProvisionedSystemable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSProvisioningProvisionedSystem(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedSystemPrimer(recurse bool, tkh keyhubmodel.ProvisioningProvisionedSystemPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedSystemPrimerAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedSystemPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSOrganizationOrganizationalUnitPrimer(recurse, tkh.GetOrganizationalUnit())
		diags.Append(d...)
		obj["organizational_unit"] = val
	}
	obj["type"] = stringerToTF(tkh.GetProvisioningProvisionedSystemPrimerType())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedSystemPrimerLinkableWrapper(recurse bool, tkh keyhubmodel.ProvisioningProvisionedSystemPrimerLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedSystemPrimerLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedSystemPrimerLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ProvisioningProvisionedSystemPrimerable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimer(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisionedSystem_additionalObjects(recurse bool, tkh keyhubmodel.ProvisioningProvisionedSystem_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisionedSystem_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisionedSystem_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedAccount(recurse, tkh.GetAccount())
		diags.Append(d...)
		obj["account"] = val
	}
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSClientOAuth2ClientPermissionWithClientLinkableWrapper(recurse, tkh.GetIssuedPermissions())
		diags.Append(d...)
		obj["issued_permissions"] = getItemsAttr(val, attrs["issued_permissions"])
	}
	obj["login_name"] = types.StringPointerValue(tkh.GetLoginName())
	{
		val, d := tkhToTFObjectDSProvisioningProvisioningManagementPermissions(recurse, tkh.GetManagementPermissions())
		diags.Append(d...)
		obj["management_permissions"] = val
	}
	{
		val, d := tkhToTFObjectDSMarkItemMarkers(recurse, tkh.GetMarkers())
		diags.Append(d...)
		obj["markers"] = val
	}
	{
		val, d := tkhToTFObjectDSProvisioningCircuitBreakerStatistics(recurse, tkh.GetStatistics())
		diags.Append(d...)
		obj["statistics"] = val
	}
	{
		val, d := tkhToTFObjectDSProvisioningGroupOnSystemTypes(recurse, tkh.GetSupportedGroupTypes())
		diags.Append(d...)
		obj["supported_group_types"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSProvisioningProvisioningManagementPermissions(recurse bool, tkh keyhubmodel.ProvisioningProvisioningManagementPermissionsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = provisioningProvisioningManagementPermissionsAttrTypesDSRecurse
	} else {
		attrs = provisioningProvisioningManagementPermissionsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["create_new_groups_allowed"] = types.BoolPointerValue(tkh.GetCreateNewGroupsAllowed())
	obj["create_service_accounts_allowed"] = types.BoolPointerValue(tkh.GetCreateServiceAccountsAllowed())
	obj["reuse_existing_groups_allowed"] = types.BoolPointerValue(tkh.GetReuseExistingGroupsAllowed())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccount(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccountable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccountAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccountAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSServiceaccountServiceAccount_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimer(recurse, tkh.GetSystem())
		diags.Append(d...)
		obj["system"] = val
	}
	obj["username"] = types.StringPointerValue(tkh.GetUsername())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["description"] = types.StringPointerValue(tkh.GetDescription())
	{
		val, d := tkhToTFObjectDSVaultVaultRecordPrimer(false, tkh.GetPassword())
		diags.Append(d...)
		obj["password"] = val
	}
	obj["password_rotation"] = stringerToTF(tkh.GetPasswordRotation())
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetTechnicalAdministrator())
		diags.Append(d...)
		obj["technical_administrator"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccountGroup(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccountGroupable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccountGroupAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccountGroupAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSServiceaccountServiceAccountGroup_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["display_name"] = types.StringPointerValue(tkh.GetDisplayName())
	obj["name_in_system"] = types.StringPointerValue(tkh.GetNameInSystem())
	obj["type"] = stringerToTF(tkh.GetProvisioningGroupOnSystemPrimerType())
	obj["short_name_in_system"] = types.StringPointerValue(tkh.GetShortNameInSystem())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccountGroupLinkableWrapper(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccountGroupLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccountGroupLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccountGroupLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ServiceaccountServiceAccountGroupable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSServiceaccountServiceAccountGroup(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccountGroup_additionalObjects(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccountGroup_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccountGroup_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccountGroup_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccountLinkableWrapper(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccountLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccountLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccountLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ServiceaccountServiceAccountable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSServiceaccountServiceAccount(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccountPrimer(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccountPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccountPrimerAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccountPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimer(recurse, tkh.GetSystem())
		diags.Append(d...)
		obj["system"] = val
	}
	obj["username"] = types.StringPointerValue(tkh.GetUsername())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccountPrimerLinkableWrapper(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccountPrimerLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccountPrimerLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccountPrimerLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.ServiceaccountServiceAccountPrimerable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSServiceaccountServiceAccountPrimer(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSServiceaccountServiceAccount_additionalObjects(recurse bool, tkh keyhubmodel.ServiceaccountServiceAccount_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = serviceaccountServiceAccount_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = serviceaccountServiceAccount_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSServiceaccountServiceAccountGroupLinkableWrapper(recurse, tkh.GetGroups())
		diags.Append(d...)
		obj["groups"] = getItemsAttr(val, attrs["groups"])
	}
	{
		val, d := tkhToTFObjectDSGeneratedSecret(recurse, tkh.GetSecret())
		diags.Append(d...)
		obj["secret"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultPasswordMetadata(recurse bool, tkh keyhubmodel.VaultPasswordMetadataable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultPasswordMetadataAttrTypesDSRecurse
	} else {
		attrs = vaultPasswordMetadataAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["dictionary"] = types.BoolPointerValue(tkh.GetDictionary())
	obj["duplicate"] = types.BoolPointerValue(tkh.GetDuplicate())
	obj["hash"] = types.StringPointerValue(tkh.GetHash())
	obj["length"] = types.Int64PointerValue(int32PToInt64P(tkh.GetLength()))
	obj["lower_count"] = types.Int64PointerValue(int32PToInt64P(tkh.GetLowerCount()))
	obj["number_count"] = types.Int64PointerValue(int32PToInt64P(tkh.GetNumberCount()))
	obj["special_count"] = types.Int64PointerValue(int32PToInt64P(tkh.GetSpecialCount()))
	obj["strength"] = types.Int64PointerValue(int32PToInt64P(tkh.GetStrength()))
	obj["upper_count"] = types.Int64PointerValue(int32PToInt64P(tkh.GetUpperCount()))

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVault(recurse bool, tkh keyhubmodel.VaultVaultable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultAttrTypesDSRecurse
	} else {
		attrs = vaultVaultAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["access_available"] = types.BoolPointerValue(tkh.GetAccessAvailable())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		elemType := attrs["records"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetRecords(), func(tkh keyhubmodel.VaultVaultRecordable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSVaultVaultRecord(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["records"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultHolder(recurse bool, tkh keyhubmodel.VaultVaultHolderable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultHolderAttrTypesDSRecurse
	} else {
		attrs = vaultVaultHolderAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultRecord(recurse bool, tkh keyhubmodel.VaultVaultRecordable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultRecordAttrTypesDSRecurse
	} else {
		attrs = vaultVaultRecordAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSVaultVaultRecord_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["color"] = stringerToTF(tkh.GetColor())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["share_end_time"] = timePointerToTF(tkh.GetShareEndTime())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["derived"] = types.BoolPointerValue(tkh.GetDerived())
	obj["end_date"] = stringerToTF(tkh.GetEndDate())
	obj["filename"] = types.StringPointerValue(tkh.GetFilename())
	{
		elemType := attrs["types"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetTypes(), func(tkh keyhubmodel.VaultVaultSecretType, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.String())
		})
		diags.Append(d...)
		obj["types"] = val
	}
	obj["url"] = types.StringPointerValue(tkh.GetUrl())
	obj["username"] = types.StringPointerValue(tkh.GetUsername())
	obj["warning_period"] = stringerToTF(tkh.GetWarningPeriod())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultRecordPrimer(recurse bool, tkh keyhubmodel.VaultVaultRecordPrimerable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultRecordPrimerAttrTypesDSRecurse
	} else {
		attrs = vaultVaultRecordPrimerAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	obj["color"] = stringerToTF(tkh.GetColor())
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["share_end_time"] = timePointerToTF(tkh.GetShareEndTime())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultRecordPrimerLinkableWrapper(recurse bool, tkh keyhubmodel.VaultVaultRecordPrimerLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultRecordPrimerLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = vaultVaultRecordPrimerLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.VaultVaultRecordPrimerable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSVaultVaultRecordPrimer(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultRecordSecrets(recurse bool, tkh keyhubmodel.VaultVaultRecordSecretsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultRecordSecretsAttrTypesDSRecurse
	} else {
		attrs = vaultVaultRecordSecretsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["comment"] = types.StringPointerValue(tkh.GetComment())
	obj["file"] = types.StringPointerValue(tkh.GetFile())
	obj["password"] = types.StringPointerValue(tkh.GetPassword())
	obj["totp"] = types.StringPointerValue(tkh.GetTotp())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultRecordShare(recurse bool, tkh keyhubmodel.VaultVaultRecordShareable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultRecordShareAttrTypesDSRecurse
	} else {
		attrs = vaultVaultRecordShareAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	obj["name"] = types.StringPointerValue(tkh.GetName())
	obj["type"] = stringerToTF(tkh.GetVaultVaultRecordShareType())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultRecordShareSummary(recurse bool, tkh keyhubmodel.VaultVaultRecordShareSummaryable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultRecordShareSummaryAttrTypesDSRecurse
	} else {
		attrs = vaultVaultRecordShareSummaryAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["children"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetChildren(), func(tkh keyhubmodel.VaultVaultRecordShareable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSVaultVaultRecordShare(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["children"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVaultRecordShare(recurse, tkh.GetParent())
		diags.Append(d...)
		obj["parent"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSVaultVaultRecord_additionalObjects(recurse bool, tkh keyhubmodel.VaultVaultRecord_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = vaultVaultRecord_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = vaultVaultRecord_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVaultRecordPrimer(recurse, tkh.GetParent())
		diags.Append(d...)
		obj["parent"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultPasswordMetadata(recurse, tkh.GetPasswordMetadata())
		diags.Append(d...)
		obj["password_metadata"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVaultRecordSecrets(recurse, tkh.GetSecret())
		diags.Append(d...)
		obj["secret"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVaultRecordShareSummary(recurse, tkh.GetShareSummary())
		diags.Append(d...)
		obj["share_summary"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVaultRecordPrimerLinkableWrapper(recurse, tkh.GetShares())
		diags.Append(d...)
		obj["shares"] = getItemsAttr(val, attrs["shares"])
	}
	{
		val, d := tkhToTFObjectDSLaunchpadVaultRecordLaunchpadTile(recurse, tkh.GetTile())
		diags.Append(d...)
		obj["tile"] = val
	}
	{
		val, d := tkhToTFObjectDSVaultVaultHolder(recurse, tkh.GetVaultholder())
		diags.Append(d...)
		obj["vaultholder"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSWebhookWebhook(recurse bool, tkh keyhubmodel.WebhookWebhookable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = webhookWebhookAttrTypesDSRecurse
	} else {
		attrs = webhookWebhookAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	if recurse {
		obj["additional"] = types.ListNull(types.StringType)
	}
	if recurse {
		{
			val, d := tkhToTFObjectDSWebhookWebhook_additionalObjects(false, tkh.GetAdditionalObjects())
			diags.Append(d...)
			maps.Copy(obj, val.Attributes())
		}
	}
	{
		elemType := attrs["links"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetLinks(), func(tkh keyhubmodel.RestLinkable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSRestLink(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["links"] = val
	}
	{
		elemType := attrs["permissions"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetPermissions(), func(tkh keyhubmodel.AuthPermissionable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSAuthPermission(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["permissions"] = val
	}
	{
		val, d := tkhToTFObjectDSAuthAccountPrimer(false, tkh.GetAccount())
		diags.Append(d...)
		obj["account"] = val
	}
	obj["active"] = types.BoolPointerValue(tkh.GetActive())
	obj["all_types"] = types.BoolPointerValue(tkh.GetAllTypes())
	obj["authentication_scheme"] = stringerToTF(tkh.GetAuthenticationScheme())
	obj["basic_auth_password"] = types.StringPointerValue(tkh.GetBasicAuthPassword())
	obj["basic_auth_username"] = types.StringPointerValue(tkh.GetBasicAuthUsername())
	obj["bearer_token"] = types.StringPointerValue(tkh.GetBearerToken())
	{
		val, d := tkhToTFObjectDSClientClientApplicationPrimer(false, tkh.GetClient())
		diags.Append(d...)
		obj["client"] = val
	}
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(false, tkh.GetClientCertificate())
		diags.Append(d...)
		obj["client_certificate"] = val
	}
	obj["custom_header_name"] = types.StringPointerValue(tkh.GetCustomHeaderName())
	obj["custom_header_value"] = types.StringPointerValue(tkh.GetCustomHeaderValue())
	{
		val, d := tkhToTFObjectDSDirectoryAccountDirectoryPrimer(false, tkh.GetDirectory())
		diags.Append(d...)
		obj["directory"] = val
	}
	{
		val, d := tkhToTFObjectDSGroupGroupPrimer(false, tkh.GetGroup())
		diags.Append(d...)
		obj["group"] = val
	}
	obj["name"] = types.StringPointerValue(tkh.GetName())
	{
		val, d := tkhToTFObjectDSProvisioningProvisionedSystemPrimer(false, tkh.GetSystem())
		diags.Append(d...)
		obj["system"] = val
	}
	obj["tls"] = stringerToTF(tkh.GetTls())
	{
		val, d := tkhToTFObjectDSCertificateCertificatePrimer(false, tkh.GetTrustedCertificate())
		diags.Append(d...)
		obj["trusted_certificate"] = val
	}
	{
		elemType := attrs["types"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetTypes(), func(tkh keyhubmodel.AuditAuditRecordType, diags *diag.Diagnostics) attr.Value {
			return types.StringValue(tkh.String())
		})
		diags.Append(d...)
		obj["types"] = val
	}
	obj["url"] = types.StringPointerValue(tkh.GetUrl())
	obj["uuid"] = types.StringPointerValue(tkh.GetUuid())
	obj["verbose_payloads"] = types.BoolPointerValue(tkh.GetVerbosePayloads())

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSWebhookWebhookLinkableWrapper(recurse bool, tkh keyhubmodel.WebhookWebhookLinkableWrapperable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = webhookWebhookLinkableWrapperAttrTypesDSRecurse
	} else {
		attrs = webhookWebhookLinkableWrapperAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		elemType := attrs["items"].(types.ListType).ElemType
		val, d := sliceToTF(elemType, tkh.GetItems(), func(tkh keyhubmodel.WebhookWebhookable, diags *diag.Diagnostics) attr.Value {
			val, d := tkhToTFObjectDSWebhookWebhook(recurse, tkh)
			diags.Append(d...)
			return val
		})
		diags.Append(d...)
		obj["items"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}

func tkhToTFObjectDSWebhookWebhook_additionalObjects(recurse bool, tkh keyhubmodel.WebhookWebhook_additionalObjectsable) (types.Object, diag.Diagnostics) {
	var diags diag.Diagnostics
	var attrs map[string]attr.Type
	if recurse {
		attrs = webhookWebhook_additionalObjectsAttrTypesDSRecurse
	} else {
		attrs = webhookWebhook_additionalObjectsAttrTypesDS
	}
	if tkh == nil {
		return types.ObjectNull(attrs), diags
	}

	obj := make(map[string]attr.Value)
	{
		val, d := tkhToTFObjectDSAuditInfo(recurse, tkh.GetAudit())
		diags.Append(d...)
		obj["audit"] = val
	}

	objVal, d := types.ObjectValue(attrs, obj)
	diags.Append(d...)
	return objVal, diags
}