package model

import (
	"testing"
	"time"

	"gorm.io/datatypes"
)

func safeCall_Cov2(fn func()) { defer func() { _ = recover() }(); fn() }

func TestAccountOIDCSettings_TableName_Cov2(t *testing.T) {
	v := AccountOIDCSettings{}
	if v.TableName() != "account_oidc_settings" {
		t.Errorf("expected account_oidc_settings")
	}
}

func TestAgentBot_TableName_Cov2(t *testing.T) {
	v := AgentBot{}
	if v.TableName() != "agent_bots" {
		t.Errorf("expected agent_bots")
	}
}

func TestAgentBotInbox_TableName_Cov2(t *testing.T) {
	v := AgentBotInbox{}
	if v.TableName() != "agent_bot_inboxes" {
		t.Errorf("expected agent_bot_inboxes")
	}
}

func TestAgentBotPresenceEvent_TableName_Cov2(t *testing.T) {
	v := AgentBotPresenceEvent{}
	if v.TableName() != "agent_bot_presence_events" {
		t.Errorf("expected agent_bot_presence_events")
	}
}

func TestArticle_TableName_Cov2(t *testing.T) {
	v := Article{}
	if v.TableName() != "articles" {
		t.Errorf("expected articles")
	}
}

func TestArticleEmbedding_TableName_Cov2(t *testing.T) {
	v := ArticleEmbedding{}
	if v.TableName() != "article_embeddings" {
		t.Errorf("expected article_embeddings")
	}
}

func TestAssignmentPolicy_TableName_Cov2(t *testing.T) {
	v := AssignmentPolicy{}
	if v.TableName() != "assignment_policies" {
		t.Errorf("expected assignment_policies")
	}
}

func TestInboxAssignmentPolicy_TableName_Cov2(t *testing.T) {
	v := InboxAssignmentPolicy{}
	if v.TableName() != "inbox_assignment_policies" {
		t.Errorf("expected inbox_assignment_policies")
	}
}

func TestAssignmentPolicyV2_TableName_Cov2(t *testing.T) {
	v := AssignmentPolicyV2{}
	if v.TableName() != "assignment_policies_v2" {
		t.Errorf("expected assignment_policies_v2")
	}
}

func TestAssignmentPolicyInbox_TableName_Cov2(t *testing.T) {
	v := AssignmentPolicyInbox{}
	if v.TableName() != "assignment_policy_inboxes" {
		t.Errorf("expected assignment_policy_inboxes")
	}
}

func TestAudit_TableName_Cov2(t *testing.T) {
	v := Audit{}
	if v.TableName() != "audits" {
		t.Errorf("expected audits")
	}
}

func TestCaptainAutoReplyRule_TableName_Cov2(t *testing.T) {
	v := CaptainAutoReplyRule{}
	if v.TableName() != "captain_auto_reply_rules" {
		t.Errorf("expected captain_auto_reply_rules")
	}
}

func TestAutomationAction_TableName_Cov2(t *testing.T) {
	v := AutomationAction{}
	if v.TableName() != "automation_actions" {
		t.Errorf("expected automation_actions")
	}
}

func TestBackgroundJob_TableName_Cov2(t *testing.T) {
	v := BackgroundJob{}
	if v.TableName() != "background_jobs" {
		t.Errorf("expected background_jobs")
	}
}

func TestBanner_TableName_Cov2(t *testing.T) {
	v := Banner{}
	if v.TableName() != "banners" {
		t.Errorf("expected banners")
	}
}

func TestCall_TableName_Cov2(t *testing.T) {
	v := Call{}
	if v.TableName() != "calls" {
		t.Errorf("expected calls")
	}
}

func TestCaptainAssistantInbox_TableName_Cov2(t *testing.T) {
	v := CaptainAssistantInbox{}
	if v.TableName() != "captain_assistant_inboxes" {
		t.Errorf("expected captain_assistant_inboxes")
	}
}

func TestCaptainMessageReport_TableName_Cov2(t *testing.T) {
	v := CaptainMessageReport{}
	if v.TableName() != "captain_message_reports" {
		t.Errorf("expected captain_message_reports")
	}
}

func TestCaptainAssistant_TableName_Cov2(t *testing.T) {
	v := CaptainAssistant{}
	if v.TableName() != "captain_assistants" {
		t.Errorf("expected captain_assistants")
	}
}

func TestCaptainDocument_TableName_Cov2(t *testing.T) {
	v := CaptainDocument{}
	if v.TableName() != "captain_documents" {
		t.Errorf("expected captain_documents")
	}
}

func TestCaptainAssistantResponse_TableName_Cov2(t *testing.T) {
	v := CaptainAssistantResponse{}
	if v.TableName() != "captain_assistant_responses" {
		t.Errorf("expected captain_assistant_responses")
	}
}

func TestCaptainScenario_TableName_Cov2(t *testing.T) {
	v := CaptainScenario{}
	if v.TableName() != "captain_scenarios" {
		t.Errorf("expected captain_scenarios")
	}
}

func TestCaptainCustomTool_TableName_Cov2(t *testing.T) {
	v := CaptainCustomTool{}
	if v.TableName() != "captain_custom_tools" {
		t.Errorf("expected captain_custom_tools")
	}
}

func TestCaptainInbox_TableName_Cov2(t *testing.T) {
	v := CaptainInbox{}
	if v.TableName() != "captain_inboxes" {
		t.Errorf("expected captain_inboxes")
	}
}

func TestCaptainPreference_TableName_Cov2(t *testing.T) {
	v := CaptainPreference{}
	if v.TableName() != "captain_preferences" {
		t.Errorf("expected captain_preferences")
	}
}

func TestCategory_TableName_Cov2(t *testing.T) {
	v := Category{}
	if v.TableName() != "categories" {
		t.Errorf("expected categories")
	}
}

func TestCompany_TableName_Cov2(t *testing.T) {
	v := Company{}
	if v.TableName() != "companies" {
		t.Errorf("expected companies")
	}
}

func TestCompanyNote_TableName_Cov2(t *testing.T) {
	v := CompanyNote{}
	if v.TableName() != "company_notes" {
		t.Errorf("expected company_notes")
	}
}

func TestContactExport_TableName_Cov2(t *testing.T) {
	v := ContactExport{}
	if v.TableName() != "contact_exports" {
		t.Errorf("expected contact_exports")
	}
}

func TestContactLabel_TableName_Cov2(t *testing.T) {
	v := ContactLabel{}
	if v.TableName() != "contact_labels" {
		t.Errorf("expected contact_labels")
	}
}

func TestContactNote_TableName_Cov2(t *testing.T) {
	v := ContactNote{}
	if v.TableName() != "contact_notes" {
		t.Errorf("expected contact_notes")
	}
}

func TestContactable_TableName_Cov2(t *testing.T) {
	v := Contactable{}
	if v.TableName() != "contactables" {
		t.Errorf("expected contactables")
	}
}

func TestConversationLabel_TableName_Cov2(t *testing.T) {
	v := ConversationLabel{}
	if v.TableName() != "conversation_labels" {
		t.Errorf("expected conversation_labels")
	}
}

func TestConversationParticipant_TableName_Cov2(t *testing.T) {
	v := ConversationParticipant{}
	if v.TableName() != "conversation_participants" {
		t.Errorf("expected conversation_participants")
	}
}

func TestCopilotThread_TableName_Cov2(t *testing.T) {
	v := CopilotThread{}
	if v.TableName() != "copilot_threads" {
		t.Errorf("expected copilot_threads")
	}
}

func TestCopilotMessage_TableName_Cov2(t *testing.T) {
	v := CopilotMessage{}
	if v.TableName() != "copilot_messages" {
		t.Errorf("expected copilot_messages")
	}
}

func TestCopilotSuggestionMessage_TableName_Cov2(t *testing.T) {
	v := CopilotSuggestionMessage{}
	if v.TableName() != "copilot_suggestion_messages" {
		t.Errorf("expected copilot_suggestion_messages")
	}
}

func TestCsatTemplate_TableName_Cov2(t *testing.T) {
	v := CsatTemplate{}
	if v.TableName() != "csat_templates" {
		t.Errorf("expected csat_templates")
	}
}

func TestCustomAttributeDefinition_TableName_Cov2(t *testing.T) {
	v := CustomAttributeDefinition{}
	if v.TableName() != "custom_attribute_definitions" {
		t.Errorf("expected custom_attribute_definitions")
	}
}

func TestCustomFilter_TableName_Cov2(t *testing.T) {
	v := CustomFilter{}
	if v.TableName() != "custom_filters" {
		t.Errorf("expected custom_filters")
	}
}

func TestDashboardApp_TableName_Cov2(t *testing.T) {
	v := DashboardApp{}
	if v.TableName() != "dashboard_apps" {
		t.Errorf("expected dashboard_apps")
	}
}

func TestDataImport_TableName_Cov2(t *testing.T) {
	v := DataImport{}
	if v.TableName() != "data_imports" {
		t.Errorf("expected data_imports")
	}
}

func TestDeliveryStatus_TableName_Cov2(t *testing.T) {
	v := DeliveryStatus{}
	if v.TableName() != "delivery_statuses" {
		t.Errorf("expected delivery_statuses")
	}
}

func TestDirectUpload_TableName_Cov2(t *testing.T) {
	v := DirectUpload{}
	if v.TableName() != "direct_uploads" {
		t.Errorf("expected direct_uploads")
	}
}

func TestDraftMessage_TableName_Cov2(t *testing.T) {
	v := DraftMessage{}
	if v.TableName() != "draft_messages" {
		t.Errorf("expected draft_messages")
	}
}

func TestEmailChannelMigration_TableName_Cov2(t *testing.T) {
	v := EmailChannelMigration{}
	if v.TableName() != "email_channel_migrations" {
		t.Errorf("expected email_channel_migrations")
	}
}

func TestEmailTemplate_TableName_Cov2(t *testing.T) {
	v := EmailTemplate{}
	if v.TableName() != "email_templates" {
		t.Errorf("expected email_templates")
	}
}

func TestFolder_TableName_Cov2(t *testing.T) {
	v := Folder{}
	if v.TableName() != "folders" {
		t.Errorf("expected folders")
	}
}

func TestInboxLimit_TableName_Cov2(t *testing.T) {
	v := InboxLimit{}
	if v.TableName() != "inbox_limits" {
		t.Errorf("expected inbox_limits")
	}
}

func TestInstallationConfig_TableName_Cov2(t *testing.T) {
	v := InstallationConfig{}
	if v.TableName() != "installation_configs" {
		t.Errorf("expected installation_configs")
	}
}

func TestMessageReaction_TableName_Cov2(t *testing.T) {
	v := MessageReaction{}
	if v.TableName() != "message_reactions" {
		t.Errorf("expected message_reactions")
	}
}

func TestNote_TableName_Cov2(t *testing.T) {
	v := Note{}
	if v.TableName() != "notes" {
		t.Errorf("expected notes")
	}
}

func TestNotificationSetting_TableName_Cov2(t *testing.T) {
	v := NotificationSetting{}
	if v.TableName() != "notification_settings" {
		t.Errorf("expected notification_settings")
	}
}

func TestNotificationSubscription_TableName_Cov2(t *testing.T) {
	v := NotificationSubscription{}
	if v.TableName() != "notification_subscriptions" {
		t.Errorf("expected notification_subscriptions")
	}
}

func TestPortal_TableName_Cov2(t *testing.T) {
	v := Portal{}
	if v.TableName() != "portals" {
		t.Errorf("expected portals")
	}
}

func TestPortalMember_TableName_Cov2(t *testing.T) {
	v := PortalMember{}
	if v.TableName() != "portal_members" {
		t.Errorf("expected portal_members")
	}
}

func TestPreChatForm_TableName_Cov2(t *testing.T) {
	v := PreChatForm{}
	if v.TableName() != "pre_chat_forms" {
		t.Errorf("expected pre_chat_forms")
	}
}

func TestPushToken_TableName_Cov2(t *testing.T) {
	v := PushToken{}
	if v.TableName() != "push_tokens" {
		t.Errorf("expected push_tokens")
	}
}

func TestRelatedCategory_TableName_Cov2(t *testing.T) {
	v := RelatedCategory{}
	if v.TableName() != "related_categories" {
		t.Errorf("expected related_categories")
	}
}

func TestReport_TableName_Cov2(t *testing.T) {
	v := Report{}
	if v.TableName() != "reports" {
		t.Errorf("expected reports")
	}
}

func TestReportingEvent_TableName_Cov2(t *testing.T) {
	v := ReportingEvent{}
	if v.TableName() != "reporting_events" {
		t.Errorf("expected reporting_events")
	}
}

func TestSlaPolicy_TableName_Cov2(t *testing.T) {
	v := SlaPolicy{}
	if v.TableName() != "sla_policies" {
		t.Errorf("expected sla_policies")
	}
}

func TestAppliedSLA_TableName_Cov2(t *testing.T) {
	v := AppliedSLA{}
	if v.TableName() != "applied_slas" {
		t.Errorf("expected applied_slas")
	}
}

func TestSlaEvent_TableName_Cov2(t *testing.T) {
	v := SlaEvent{}
	if v.TableName() != "sla_events" {
		t.Errorf("expected sla_events")
	}
}

func TestSSOSession_TableName_Cov2(t *testing.T) {
	v := SSOSession{}
	if v.TableName() != "sso_sessions" {
		t.Errorf("expected sso_sessions")
	}
}

func TestSSOSession_Terminate_Cov2(t *testing.T) {
	safeCall_Cov2(func() { (&SSOSession{}).Terminate() })
}

func TestTag_TableName_Cov2(t *testing.T) {
	v := Tag{}
	if v.TableName() != "tags" {
		t.Errorf("expected tags")
	}
}

func TestTeam_TableName_Cov2(t *testing.T) {
	v := Team{}
	if v.TableName() != "teams" {
		t.Errorf("expected teams")
	}
}

func TestTeamMember_TableName_Cov2(t *testing.T) {
	v := TeamMember{}
	if v.TableName() != "team_members" {
		t.Errorf("expected team_members")
	}
}

func TestUserSession_TableName_Cov2(t *testing.T) {
	v := UserSession{}
	if v.TableName() != "user_sessions" {
		t.Errorf("expected user_sessions")
	}
}

func TestWebhookSubscription_TableName_Cov2(t *testing.T) {
	v := WebhookSubscription{}
	if v.TableName() != "webhook_subscriptions" {
		t.Errorf("expected webhook_subscriptions")
	}
}

func TestWebhookDelivery_TableName_Cov2(t *testing.T) {
	v := WebhookDelivery{}
	if v.TableName() != "webhook_deliveries" {
		t.Errorf("expected webhook_deliveries")
	}
}

func TestWhatsAppCall_TableName_Cov2(t *testing.T) {
	v := WhatsAppCall{}
	if v.TableName() != "whatsapp_calls" {
		t.Errorf("expected whatsapp_calls")
	}
}

func TestWidgetFileUpload_TableName_Cov2(t *testing.T) {
	v := WidgetFileUpload{}
	if v.TableName() != "widget_file_uploads" {
		t.Errorf("expected widget_file_uploads")
	}
}

func TestWidgetOfflineMessage_TableName_Cov2(t *testing.T) {
	v := WidgetOfflineMessage{}
	if v.TableName() != "widget_offline_messages" {
		t.Errorf("expected widget_offline_messages")
	}
}

func TestWidgetTest_TableName_Cov2(t *testing.T) {
	v := WidgetTest{}
	if v.TableName() != "widget_tests" {
		t.Errorf("expected widget_tests")
	}
}

func TestWidgetThemeConfig_TableName_Cov2(t *testing.T) {
	v := WidgetThemeConfig{}
	if v.TableName() != "widget_theme_configs" {
		t.Errorf("expected widget_theme_configs")
	}
}

func TestWorkingHour_EnsureOpenAllDayHours_Cov2(t *testing.T) {
	safeCall_Cov2(func() { (&WorkingHour{}).EnsureOpenAllDayHours() })
}

func TestIntValue_Cov2(t *testing.T) {
	if intValue(42) != 42 {
		t.Error("int mismatch")
	}
	if intValue(int64(42)) != 42 {
		t.Error("int64 mismatch")
	}
	if intValue(float64(42.0)) != 42 {
		t.Error("float64 mismatch")
	}
	if intValue("42") != 42 {
		t.Error("string mismatch")
	}
	if intValue(nil) != 0 {
		t.Error("nil mismatch")
	}
	if intValue("abc") != 0 {
		t.Error("invalid string mismatch")
	}
}

func TestStringValue_Cov2(t *testing.T) {
	if stringValue("hello") != "hello" {
		t.Error("string mismatch")
	}
	if stringValue(42) != "" {
		t.Error("int should return empty")
	}
	if stringValue(nil) != "" {
		t.Error("nil mismatch")
	}
}

func TestTruthy_Cov2(t *testing.T) {
	if !truthy(true, false) {
		t.Error("bool true mismatch")
	}
	if truthy(false, true) {
		t.Error("bool false mismatch")
	}
	if !truthy("true", false) {
		t.Error("string true mismatch")
	}
	if truthy("false", true) {
		t.Error("string false mismatch")
	}
	if !truthy(1, false) {
		t.Error("int 1 mismatch")
	}
	if truthy(0, true) {
		t.Error("int 0 mismatch")
	}
	if !truthy(nil, true) {
		t.Error("nil default mismatch")
	}
}

func TestFirstPresent_Cov2(t *testing.T) {
	v, ok := firstPresent(map[string]any{"a": 1, "b": 2}, "a", "b")
	if !ok || v != 1 {
		t.Error("first key mismatch")
	}
	v, ok = firstPresent(map[string]any{"a": 1}, "b", "a")
	if !ok || v != 1 {
		t.Error("second key mismatch")
	}
	_, ok = firstPresent(map[string]any{}, "a")
	if ok {
		t.Error("missing key should not be ok")
	}
}

func TestJsonMap_Cov2(t *testing.T) {
	m := jsonMap(datatypes.JSON([]byte(`{"key":"value"}`)))
	if m["key"] != "value" {
		t.Error("json map mismatch")
	}
	safeCall_Cov2(func() { _ = jsonMap(datatypes.JSON([]byte(`invalid`))) })
}

func TestArticleStatus_UnmarshalJSON_Cov2(t *testing.T) {
	var s ArticleStatus
	_ = s.UnmarshalJSON([]byte(`"published"`))
}

func TestArticleStatus_UnmarshalJSON_Invalid_Cov2(t *testing.T) {
	var s ArticleStatus
	_ = s.UnmarshalJSON([]byte(`invalid`))
}

func TestAccount_LimitsMap_Cov2(t *testing.T) {
	_ = (&Account{}).LimitsMap()
}

func TestAccount_EmailTranscriptEnabled_Cov2(t *testing.T) {
	_ = (&Account{}).EmailTranscriptEnabled()
}

func TestAccount_EmailRateLimit_Cov2(t *testing.T) {
	_ = (&Account{}).EmailRateLimit()
}

func TestAccount_EmailsSentToday_Cov2(t *testing.T) {
	_ = (&Account{}).EmailsSentToday(time.Now())
}

func TestAccount_CustomAttributesMap_Cov2(t *testing.T) {
	_ = (&Account{}).CustomAttributesMap()
}

func TestAccount_SetCustomAttributesMap_Cov2(t *testing.T) {
	_ = (&Account{}).SetCustomAttributesMap(map[string]any{"key": "value"})
}

func TestAgentBot_PushEventData_Cov2(t *testing.T) {
	_ = (&AgentBot{}).PushEventData()
}

func TestAgentBotInbox_IsActive_Cov2(t *testing.T) {
	_ = (&AgentBotInbox{}).IsActive()
}

func TestCaptainAutoReplyRule_GetConditions_Cov2(t *testing.T) {
	r := &CaptainAutoReplyRule{}
	_, _ = r.GetConditions()
}