apiresource

var SampleAPIKey = &APIKey{
	ID:            SampleAPIKeyID,
	Object:        constants.ObjectTypeAPIKey,
	Name:          SampleAPIKeyName,
	RedactedValue: SampleProdAPIKeyRedactedValue,
	Role:          SampleRole,
	LastUsedAt:    timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	ExpiresAt:     timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
	RevokedAt:     nil,
	CreatedAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:     timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccount = &Account{
	ID:                     SampleAccountID,
	Object:                 constants.ObjectTypeAccount,
	Name:                   SampleAccountName,
	DefaultBillingAddress:  SampleAddress,
	DefaultShippingAddress: SampleAddress,
	Branding:               SampleAccountBranding,
	Portal:                 SampleAccountPortal,
	CreatedAt:              timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:              timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountBranding = &AccountBranding{
	ID:              SampleAccountBrandingID,
	Object:          constants.ObjectTypeAccountBranding,
	SupportEmail:    new("support@acme.example.com"),
	PhoneNumber:     new("+1-614-555-0100"),
	LogoURL:         new("https://cdn.openmrp.ai/branding/abr_2rygb4fof28b/logo.png"),
	FaviconURL:      new("https://cdn.openmrp.ai/branding/abr_2rygb4fof28b/favicon.png"),
	FacebookHandle:  new("acmeinc"),
	InstagramHandle: new("acmeinc"),
	LinkedInHandle:  new("acme-inc"),
	TwitterHandle:   new("acmeinc"),
	WebsiteURL:      new("https://www.acme.example.com"),
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountFaviconURL = &AccountFaviconURL{
	Object: constants.ObjectTypeAccountFaviconURL,
	URL:    new("https://augno-logos.s3.amazonaws.com/ac_ykxoradjoeb3/favicon.png?X-Amz-Expires=3600&X-Amz-Signature=example"),
}

var SampleAccountGroup = &AccountGroup{
	ID:               SampleAccountGroupID,
	Object:           constants.ObjectTypeAccountGroup,
	Type:             constants.AccountGroupTypeTypeGroup,
	Name:             SampleAccountGroupName,
	Description:      nil,
	CommissionPolicy: constants.CommissionPolicyApplied,
	FreightPolicy:    constants.FreightPolicyBilled,
	CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:        timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountGroupProductLineAccess = &AccountGroupProductLineAccess{
	Object: constants.ObjectTypeAccountGroupProductLineAccess,
	AccountGroup: &AccountGroup{
		ID:               SampleAccountGroupID,
		Object:           constants.ObjectTypeAccountGroup,
		Name:             SampleAccountGroupName,
		CommissionPolicy: constants.CommissionPolicyApplied,
		FreightPolicy:    constants.FreightPolicyBilled,
		Type:             constants.AccountGroupTypePricingGroup,
		CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		UpdatedAt:        timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
	},
	ProductLines: NewList([]ProductLine{*SampleProductLine}, PageInfo{}),
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountIntegration = &AccountIntegration{
	ID:              SampleAccountIntegrationID,
	Object:          constants.ObjectTypeAccountIntegration,
	Name:            SampleAccountIntegrationName,
	IntegrationCode: constants.IntegrationCodeStripe,
	Status:          constants.AccountIntegrationStatusActive,
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountLogoURL = &AccountLogoURL{
	Object: constants.ObjectTypeAccountLogoURL,
	URL:    new("https://augno-logos.s3.amazonaws.com/ac_ykxoradjoeb3/logo.png?X-Amz-Expires=3600&X-Amz-Signature=example"),
}

var SampleAccountPhotoUploadResult = &AccountPhotoUploadResult{
	Object:  constants.ObjectTypeAccountPhotoUploadResult,
	Success: true,
}

var SampleAccountPortal = &AccountPortal{
	ID:        SampleAccountPortalID,
	Object:    constants.ObjectTypeAccountPortal,
	Slug:      SampleAccountPortalSlug,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountPrice = &AccountPrice{
	ID:               SampleAccountPriceID,
	Object:           constants.ObjectTypeAccountPrice,
	RecipientAccount: SampleCustomer,
	ProductLine:      SampleProductLine,
	Rate:             SampleRate,
	Categories:       NewList([]ItemCategory{*SampleItemCategory}, PageInfo{}),
	Attributes:       NewList([]Attribute{*SampleAttribute}, PageInfo{}),
	CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:        timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountStatus = &AccountStatus{
	ID:        SampleAccountStatusID,
	Object:    constants.ObjectTypeAccountStatus,
	Code:      SampleAccountStatusCode,
	Name:      SampleAccountStatusName,
	Owner:     SampleOwnerSystem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAccountStatusCode = constants.AccountStatusCodeNormal

var SampleAccountUsageResponse = &AccountUsageResponse{
	Object:          constants.ObjectTypeAccountUsageResponse,
	Seats:           *SampleUsageItem,
	Invoices:        *SampleUsageItemUnlimited,
	Batches:         *SampleUsageItemUnlimited,
	Sandboxes:       *SampleUsageItem,
	Subscription:    SampleSubscriptionInfo,
	AgentSpend:      SampleAgentSpendInfo,
	PlanName:        "Founder",
	BaseFeeCents:    100,
	BaseFeeInterval: "month",
}

var SampleAccountUser = &AccountUser{
	ID:                   SampleAccountUserID,
	Object:               constants.ObjectTypeAccountUser,
	Status:               constants.AccountUserStatusActive,
	Role:                 SampleRole,
	Department:           SampleDepartment,
	User:                 SampleUser,
	IsCommissionEligible: false,
	LastUsedAt:           new(timeutil.TimestampToTime(sampleUpdatedAtTimestamp)),
	CreatedAt:            timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:            timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleActor = &Actor{
	ID:        SampleUserID,
	Object:    constants.ObjectTypeActor,
	Type:      constants.ActorTypeUser,
	Name:      new(SampleUserName),
	Handle:    new(SampleUserEmail),
	AvatarURL: new(SampleUserImageUrl),
	Role:      SampleRole,
}

var SampleAddress = &Address{
	ID:     SampleCRUDAddressID,
	Object: constants.ObjectTypeAddress,
	Name:   "Headquarters",
	Phone:  &sampleAddressPhone,
	Email:  &sampleAddressEmail,
	Type:   constants.AddressTypeStandard,
	Geolocation: &Geolocation{
		ID:          SampleGeolocationID,
		Object:      constants.ObjectTypeGeolocation,
		StreetLine1: &sampleStreetLine1,
		Locality:    &sampleLocality,
		State:       &sampleState,
		PostalCode:  &samplePostalCode,
		Country:     "US",
	},
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAddressDetailsResult = &AddressDetailsResult{
	Object: constants.ObjectTypeAddressDetailsResult,
	Address: &AddressComponents{
		Object:       constants.ObjectTypeAddressComponents,
		AddressLine1: "123 Main St",
		City:         "Springfield",
		State:        "IL",
		PostalCode:   "62701",
		Country:      "United States",
		CountryCode:  "US",
	},
	FormattedAddress: "123 Main St, Springfield, IL 62701, USA",
}

var SampleAddressSuggestion = &AddressSuggestion{
	ID:            "ChIJd8BlQ2BZwokRAFUEcm_qrcA",
	Object:        constants.ObjectTypeAddressSuggestion,
	Description:   "123 Main St, Springfield, IL 62701, USA",
	MainText:      "123 Main St",
	SecondaryText: "Springfield, IL 62701, USA",
}

var SampleAdjustmentType = &AdjustmentType{
	ID:        SampleAdjustmentTypeID,
	Object:    constants.ObjectTypeAdjustmentType,
	Name:      SampleAdjustmentTypeName,
	Code:      constants.AdjustmentTypeDiscount,
	Owner:     SampleOwnerSystem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAgentAction = &AgentAction{
	ID:          SampleAgentActionID,
	Object:      constants.ObjectTypeAgentAction,
	Tool:        constants.ToolReadDoc,
	Status:      constants.AgentActionStatusExecuted,
	Label:       new("Read Doc"),
	Description: new("Read the OpenMRP documentation page on creating sales orders."),
	Run: &AgentRun{
		ID:          SampleAgentRunID,
		Object:      constants.ObjectTypeAgentRun,
		TriggerType: constants.AgentTriggerTypeManual,
		Status:      constants.AgentRunStatusCompleted,
		CreatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		UpdatedAt:   timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
	},
	Input:             json.RawMessage(`{"path":"/api/sales-orders/create"}`),
	Output:            json.RawMessage(`{"title":"Create a sales order","url":"https://docs.openmrp.ai/api-reference/sales-orders/create-sales-order"}`),
	ReviewRequirement: constants.ReviewRequirementNotRequired,
	ExecutedAt:        new(timeutil.TimestampToTime(sampleUpdatedAtTimestamp)),
	CreatedAt:         timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:         timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAgentDefinition = &AgentDefinition{
	ID:             SampleAgentDefinitionID,
	Object:         constants.ObjectTypeAgentDefinition,
	DefinitionType: constants.AgentDefinitionTypeSystem,
	CategoryCode:   "order_processing",
	TriggerType:    constants.AgentTriggerTypeEvent,
	Name:           "Email Order Agent",
	Slug:           "email_order",
	Description:    new("Processes incoming emails and creates draft orders."),
	Editability:    constants.EditabilityReadOnly,
	AccountStatus:  constants.AgentAccountStatusInactive,
	Role:           SampleRole,
	Config:         &SampleAgentDefinitionConfig,
	Tools: NewList([]AgentDefinitionTool{
		*SampleAgentDefinitionTool,
	}, PageInfo{}),
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAgentDefinitionConfig = AgentDefinitionConfig{
	Object:             constants.ObjectTypeAgentDefinitionConfig,
	SystemPrompt:       new("You are an order processing agent. Parse incoming emails and create draft orders."),
	Tier:               new(constants.ModelTierHigh),
	Temperature:        new(0.2),
	TriggerConfig:      SampleTriggerConfig,
	EndpointToolSlugs:  []string{"create_account_group"},
	EndpointToolReview: map[string]bool{"create_account_group": true},
}

var SampleAgentDefinitionTool = &AgentDefinitionTool{
	ID:                SampleAgentDefinitionToolID,
	Object:            constants.ObjectTypeAgentDefinitionTool,
	Tool:              *SampleAvailableTool,
	ReviewRequirement: constants.ReviewRequirementNotRequired,
	Config:            json.RawMessage(`{}`),
	SortOrder:         0,
}

var SampleAgentMemory = &AgentMemory{
	ID:         SampleAgentMemoryID,
	Object:     constants.ObjectTypeAgentMemory,
	Category:   constants.AgentMemoryCategoryPreference,
	Content:    "Customer prefers express shipping for all orders.",
	Metadata:   json.RawMessage(`{}`),
	Entity:     SampleCustomerEntity,
	Importance: 0.8,
	ExpiresAt:  timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAgentRun = &AgentRun{
	ID:          SampleAgentRunID,
	Object:      constants.ObjectTypeAgentRun,
	TriggerType: constants.AgentTriggerTypeManual,
	Status:      constants.AgentRunStatusCompleted,
	Definition:  SampleAgentDefinition,
	TriggeredBy: SampleActor,
	Input:       json.RawMessage(`{"message":"Process order #1234"}`),
	Output:      json.RawMessage(`{"response":"Order processed successfully"}`),
	StartedAt:   new(timeutil.TimestampToTime(sampleCreatedAtTimestamp)),
	CompletedAt: new(timeutil.TimestampToTime(sampleUpdatedAtTimestamp)),
	DurationMs:  new(int32(1250)),
	Actions:     NewList([]AgentAction{*SampleAgentAction}, PageInfo{}),
	Steps:       NewList([]AgentRunStep{*SampleAgentRunStep}, PageInfo{}),
	CreatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:   timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAgentRunStep = &AgentRunStep{
	ID:         SampleAgentRunStepID,
	Object:     constants.ObjectTypeAgentRunStep,
	StepType:   "trigger_received",
	Title:      "Run triggered",
	Content:    new("Process order #1234"),
	Sequence:   0,
	Actor:      SampleActor,
	DurationMs: new(int32(12)),
	Metadata:   json.RawMessage(`{"trigger_type":"manual"}`),
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleAgentSpendInfo = &AgentSpendInfo{
	Object:              constants.ObjectTypeAgentSpendInfo,
	EstimatedSpendCents: 1875,
	CapCents:            &sampleCapCents,
}

var SampleAllocationEntry = &AllocationEntry{
	ID:            SampleAllocationEntryID,
	Object:        constants.ObjectTypeAllocationEntry,
	Amount:        "500.000000000000000000000000000000",
	DisplayAmount: "$500.00",
	Customer: &AllocationCustomer{
		Object: constants.ObjectTypeAllocationCustomer,
		Name:   SampleCustomerName,
	},
	Transaction: &AllocationTransaction{
		ID:     SampleTransactionDetailID,
		Object: constants.ObjectTypeTransaction,
		Type:   "payment",
	},
	Invoice: &AllocationInvoice{
		ID:     SampleInvoiceID,
		Object: constants.ObjectTypeInvoiceSummary,
		Number: "INV-001",
	},
	Note:      new("Applied to the oldest open invoice first."),
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleAnalyticsPeriodEnd = timeutil.TimestampToTime(sampleUpdatedAtTimestamp)

var SampleAnalyticsPeriodStart = timeutil.TimestampToTime(sampleCreatedAtTimestamp)

var SampleAnalyzeCustomerPricingResponse = &AnalyzeCustomerPricingResponse{
	Object:   constants.ObjectTypeAnalyzeCustomerPricingResponse,
	Findings: NewList([]CustomerPricingFinding{*SampleCustomerPricingFinding}, PageInfo{}),
	Summary: CustomerPricingSummary{
		Object:                 constants.ObjectTypeCustomerPricingSummary,
		PricesAnalyzed:         412,
		BelowPeerMedianCount:   18,
		BelowTargetMarginCount: 7,
		MarginNotAssessedCount: 22,
		Notes:                  []string{},
	},
}

var SampleAnalyzeDeliveryPerformanceResponse = &AnalyzeDeliveryPerformanceResponse{
	Object: constants.ObjectTypeAnalyzeDeliveryPerformanceResponse,
	Overall: &DeliveryPerformance{
		Object:                       constants.ObjectTypeDeliveryPerformance,
		CommittedOrderCount:          26,
		ShippedOrderCount:            24,
		OnTimeOrderCount:             24,
		OnTimeInFullCount:            23,
		LateOrderCount:               2,
		NotYetShippedCount:           2,
		OnTimePct:                    &sampleOnTimePct,
		OnTimeInFullPct:              &sampleOnTimeInFullPct,
		AverageDaysLate:              &sampleAvgDaysLate,
		AverageLeadTimeDays:          &sampleAvgLeadTime,
		AverageCommittedLeadTimeDays: &sampleAvgCommittedLeadTime,
	},
	Periods: NewList([]DeliveryPerformance{}, PageInfo{}),
	Backlog: NewList([]DeliveryBacklogBucket{{
		Object:      constants.ObjectTypeDeliveryBacklogBucket,
		Label:       "1_7_days",
		MinDaysLate: 1,
		MaxDaysLate: 7,
		OrderCount:  2,
		Units:       340,
	}}, PageInfo{}),
	Lateness: NewList([]DeliveryLatenessBucket{{
		Object:       constants.ObjectTypeDeliveryLatenessBucket,
		Label:        "1_3_days",
		MinDaysLate:  1,
		MaxDaysLate:  3,
		OrderCount:   2,
		ShippedCount: 0,
		Units:        340,
	}}, PageInfo{}),
	ByCustomer: NewList([]DeliveryBreakdown{{
		Object:      constants.ObjectTypeDeliveryBreakdown,
		Key:         SampleCustomerID,
		Label:       "Northwind Textiles",
		Performance: sampleDeliveryBreakdownPerformance,
	}}, PageInfo{}),
	ByCustomerGroup: NewList([]DeliveryBreakdown{}, PageInfo{}),
	ByProductLine:   NewList([]DeliveryBreakdown{}, PageInfo{}),
	ByCommitmentSource: NewList([]DeliveryBreakdown{{
		Object:      constants.ObjectTypeDeliveryBreakdown,
		Key:         string(constants.LeadTimeSourceCustomer),
		Label:       string(constants.LeadTimeSourceCustomer),
		Performance: sampleDeliveryBreakdownPerformance,
	}}, PageInfo{}),
	UncommittedOrderCount: 0,
}

var SampleAnalyzeDemandForecastResponse = &AnalyzeDemandForecastResponse{
	Object: constants.ObjectTypeAnalyzeDemandForecastResponse,
	Data: NewList([]DemandForecastRow{
		{
			Item:                NewEntity(SampleItemID, constants.ObjectTypeItem, nil, nil),
			ProductLine:         NewEntity(SampleProductLineID, constants.ObjectTypeProductLine, nil, nil),
			ProductSku:          SampleItemSKU,
			Unit:                SampleUnitAbbreviation,
			Currency:            "USD",
			History:             []DemandForecastPoint{sampleDemandForecastHistoryPoint},
			Forecast:            []DemandForecastForecastPoint{sampleDemandForecastForecastPoint},
			RevenueHistory:      []RevenueForecastPoint{sampleRevenueForecastPoint},
			RevenueForecast:     []DemandForecastForecastPoint{sampleDemandForecastForecastPoint},
			SalesHistory:        []RevenueForecastPoint{sampleRevenueForecastPoint},
			SalesForecast:       []DemandForecastForecastPoint{sampleDemandForecastForecastPoint},
			CurrentMonthDemand:  120,
			CurrentMonthRevenue: 2400,
			CurrentMonthSales:   120,
		},
	}, PageInfo{}),
	CurrentMonthFraction: 0.35,
}

var SampleAnalyzeOeeResponse = &AnalyzeOeeResponse{
	Object: constants.ObjectTypeAnalyzeOeeResponse,
	Departments: NewList([]OeeDepartment{
		{
			Department:              NewEntity(SampleDepartmentID, constants.ObjectTypeDepartment, new(SampleDepartmentName), nil),
			GoodUnits:               980,
			WasteUnits:              20,
			SecondsUnits:            5,
			StandardSecondsEarned:   126000,
			EstimatedRuntimeHours:   40,
			AvailabilityLossSeconds: 14850,
			NotScheduledSeconds:     3600,
			DowntimeEventCount:      6,
			ScheduledSeconds:        165000,
			RunTimeSeconds:          150150,
			AvailabilityPct:         &sampleOeeTrendAvailabilityPct,
			PerformancePct:          &sampleOeeTrendPerformancePct,
			QualityPct:              &sampleOeeTrendQualityPct,
			OeePct:                  &sampleOeeTrendOeePct,
			MeasurementStatus:       constants.OeeMeasurementStatusMeasured,
		},
	}, PageInfo{}),
}

var SampleAnalyzeOeeTrendResponse = &AnalyzeOeeTrendResponse{
	Object: constants.ObjectTypeAnalyzeOeeTrendResponse,
	Periods: NewList([]OeeTrendPeriod{
		{
			StartsAt:                SampleAnalyticsPeriodStart,
			EndsAt:                  SampleAnalyticsPeriodEnd,
			GoodUnits:               980,
			WasteUnits:              20,
			SecondsUnits:            5,
			StandardSecondsEarned:   126000,
			ScheduledSeconds:        165000,
			RunTimeSeconds:          150150,
			AvailabilityLossSeconds: 14850,
			NotScheduledSeconds:     3600,
			AvailabilityPct:         &sampleOeeTrendAvailabilityPct,
			PerformancePct:          &sampleOeeTrendPerformancePct,
			QualityPct:              &sampleOeeTrendQualityPct,
			OeePct:                  &sampleOeeTrendOeePct,
			MeasurementStatus:       constants.OeeMeasurementStatusMeasured,
			DowntimeEventCount:      6,
		},
	}, PageInfo{}),
}

var SampleAnalyzeRealizedMarginsResponse = &AnalyzeRealizedMarginsResponse{
	Object:   constants.ObjectTypeAnalyzeRealizedMarginsResponse,
	Findings: NewList([]RealizedMarginFinding{*SampleRealizedMarginFinding}, PageInfo{}),
	Summary: RealizedMarginSummary{
		Object:                 constants.ObjectTypeRealizedMarginSummary,
		LinesAnalyzed:          9840,
		RelationshipsAnalyzed:  1260,
		BelowPeerMedianCount:   31,
		BelowTargetMarginCount: 12,
		MarginNotAssessedCount: 48,
		Notes:                  []string{},
	},
}

var SampleAnalyzeScheduleAttainmentResponse = &AnalyzeScheduleAttainmentResponse{
	Object:    constants.ObjectTypeAnalyzeScheduleAttainmentResponse,
	StartDate: SampleAnalyticsPeriodStart,
	EndDate:   SampleAnalyticsPeriodEnd,
	GroupBy:   constants.AttainmentGroupByWeek,
	BaselineSchedules: NewList([]Entity{
		*NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	}, PageInfo{}),
	Buckets: NewList([]AttainmentBucket{
		{
			Key:               "2026-07-27T00:00:00Z",
			Label:             "2026-07-27T00:00:00Z",
			PlannedQuantity:   4200,
			ActualQuantity:    4032,
			MatchedQuantity:   3885,
			WasteQuantity:     48,
			UnplannedQuantity: 147,
			PlannedRunHours:   63,
			PlannedLines:      7,
			BatchCount:        58,
			AttainmentPct:     &sampleAttainmentPct,
			OutputRatioPct:    &sampleOutputRatioPct,
		},
	}, PageInfo{}),
	Totals: AttainmentBucket{
		Key:               "total",
		Label:             "Total",
		PlannedQuantity:   4200,
		ActualQuantity:    4032,
		MatchedQuantity:   3885,
		WasteQuantity:     48,
		UnplannedQuantity: 147,
		PlannedRunHours:   63,
		PlannedLines:      7,
		BatchCount:        58,
		AttainmentPct:     &sampleAttainmentPct,
		OutputRatioPct:    &sampleOutputRatioPct,
	},
	FrozenAdherence: NewList([]FrozenAdherence{
		{
			Schedule:              NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
			Version:               1,
			FrozenLineCount:       8,
			FrozenPlannedQuantity: 4200,
			DeviatedLines:         1,
			AddedLines:            0,
			AbsDeltaUnits:         252,
			OffPlanLines:          1,
			OffPlanQuantity:       147,
			LineAdherencePct:      &sampleLineAdherencePct,
			UnitsAdherencePct:     &sampleUnitsAdherencePct,
		},
	}, PageInfo{}),
	BaselineStatus:        constants.AttainmentBaselineStatusMeasured,
	ScheduledMachineCount: 2,
}

var SampleAnnouncement = &Announcement{
	ID:        SampleAnnouncementID,
	Object:    constants.ObjectTypeAnnouncement,
	Scope:     constants.AnnouncementScopeAccount,
	Category:  constants.NotificationCategoryOrderUpdated,
	Status:    constants.NotificationStatusUnseen,
	Title:     "Scheduled maintenance",
	Body:      new("The platform will be briefly unavailable tonight at 2am UTC."),
	Priority:  constants.NotificationPriorityNormal,
	Resource:  NewEntity(SampleSalesOrderID, constants.ObjectTypeSalesOrder, new("Order #1042"), nil),
	PublishAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	ExpiresAt: timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAttachmentUploadTarget = &AttachmentUploadTarget{
	Object:     constants.ObjectTypeAttachmentUploadTarget,
	Attachment: SampleMessageAttachment,
	UploadURL:  "https://chat-bucket.s3.amazonaws.com/staged/ac/cv/mgah/diagram.png?X-Amz-Signature=...",
	S3Key:      "staged/ac_01h9z8q1w2e3r4t5y6u7i8o9/cv_w35z4ck68yq7/mgah_v17axle2mcff/diagram.png",
	ExpiresAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAttribute = &Attribute{
	ID:        SampleAttributeID,
	Object:    constants.ObjectTypeAttribute,
	Value:     SampleAttributeValue,
	ColorCode: constants.ColorRed,
	SortOrder: 1,
	Property: &Property{
		ID:        SamplePropertyID,
		Object:    constants.ObjectTypeProperty,
		Name:      SamplePropertyName,
		CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
	},
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleAuditEvent = &AuditEvent{
	ID:           SampleAuditEventID,
	Object:       constants.ObjectTypeAuditEvent,
	Action:       SampleAuditEventAction,
	ResourceType: SampleAuditEventResourceType,
	ResourceID:   SampleAuditEventResourceID,
	Actor:        SampleActor,
	Account:      SampleAccount,
	Changes: NewList([]AuditFieldChange{
		{
			Object:   constants.ObjectTypeAuditFieldChange,
			Field:    "email",
			OldValue: json.RawMessage(`"old@example.com"`),
			NewValue: json.RawMessage(`"new@example.com"`),
		},
	}, PageInfo{}),
	Metadata:       json.RawMessage(SampleAuditEventMetadataReason),
	Request:        SampleRequestLog,
	IdempotencyKey: new(SampleAuditEventIdempotencyKey),
	SourceIP:       new(SampleAuditEventSourceIP),
	OccurredAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleAvailableTool = &AvailableTool{
	Object:              constants.ObjectTypeAvailableTool,
	Slug:                string(SampleAvailableToolSlug),
	Category:            "built_in",
	Name:                "Lookup Customer",
	Description:         new("Look up a customer by their email address."),
	ConfigSchema:        nil,
	RequiredPermissions: []string{"customers:read"},
}

var SampleBatch = &Batch{
	ID:              SampleBatchID,
	Object:          constants.ObjectTypeBatch,
	Item:            SampleItem,
	Quantity:        SampleQuantity,
	Seconds:         SampleQuantity,
	Waste:           SampleQuantity,
	ScanningStation: SampleScanningStation,
	Department:      SampleDepartment,
	ProductionStep:  nil,
	ProductionRun:   SampleProductionRunReference,
	Machines:        NewList([]Machine{*SampleMachine}, PageInfo{}),
	Lots:            NewList([]BatchLot{*SampleBatchLot}, PageInfo{}),
	InputBatches:    NewList([]BatchReference{}, PageInfo{}),
	OutputBatches:   NewList([]BatchReference{}, PageInfo{}),
	ClosedAt:        nil,
	ScannedAt:       &sampleScannedAt,
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleBatchFlowNode = &BatchFlowNode{
	Object:        constants.ObjectTypeBatchFlowNode,
	Batch:         *SampleBatch,
	InputBatches:  NewList([]BatchReference{}, PageInfo{}),
	OutputBatches: NewList([]BatchReference{}, PageInfo{}),
}

var SampleBatchLot = &BatchLot{
	Object:    constants.ObjectTypeBatchLot,
	LotNumber: "LOT-001",
	Type:      "material",
}

var SampleBatchReference = &BatchReference{
	ID:     SampleBatchID,
	Object: constants.ObjectTypeBatch,
}

var SampleBillingPortalSessionResponse = &BillingPortalSessionResponse{
	Object: constants.ObjectTypeBillingPortalSessionResponse,
	URL:    SampleBillingPortalURL,
}

var SampleBulkReconcileItemsResponse = &BulkReconcileItemsResponse{
	Object: constants.ObjectTypeBulkReconcileItemsResponse,
	ReconciledItems: NewList([]ReconciledItemResult{
		{
			ItemID:           SampleItemID,
			SKU:              SampleItemSKU,
			PreviousQuantity: "10",
			NewQuantity:      "12",
		},
	}, PageInfo{}),
	SkippedItems: NewList([]SkippedItemResult{}, PageInfo{}),
	Errors:       NewList([]ReconcileErrorResult{}, PageInfo{}),
}

var SampleCarrier = &Carrier{
	ID:                       SampleCarrierID,
	Object:                   constants.ObjectTypeCarrier,
	Name:                     SampleCarrierName,
	Code:                     &sampleCarrierCode,
	AccountNumber:            &sampleCarrierAccountNumber,
	CustomerPortalVisibility: constants.CustomerPortalVisibilityVisible,
	Owner:                    SampleOwnerAccount,
	ServiceLevels:            NewList([]ServiceLevel{*SampleServiceLevel}, PageInfo{}),
	CreatedAt:                timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:                timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleCatalogAttribute = &CatalogAttribute{
	ID:     SampleAttributeID,
	Object: constants.ObjectTypeCatalogAttribute,
	Name:   "Red",
	Property: &CatalogProperty{
		ID:     SamplePropertyID,
		Object: constants.ObjectTypeCatalogProperty,
		Name:   "Color",
	},
}

var SampleCatalogCategory = &CatalogCategory{
	ID:         SampleItemCategoryID,
	Object:     constants.ObjectTypeCatalogCategory,
	Name:       "Finished Goods",
	Properties: NewList([]CatalogProperty{*SampleCatalogProperty}, PageInfo{}),
	Products:   NewList([]CatalogProduct{*SampleCatalogProduct}, PageInfo{}),
}

var SampleCatalogProduct = &CatalogProduct{
	Object:      constants.ObjectTypeCatalogProduct,
	Item:        SampleItem,
	Description: "Hex Bolt M10x30 Zinc",
	Attributes:  NewList([]CatalogAttribute{*SampleCatalogAttribute}, PageInfo{}),
}

var SampleCatalogProductLine = &CatalogProductLine{
	ID:     SampleProductLineID,
	Object: constants.ObjectTypeCatalogProductLine,
	Name:   "Industrial Fasteners",
}

var SampleCatalogProperty = &CatalogProperty{
	ID:     SamplePropertyID,
	Object: constants.ObjectTypeCatalogProperty,
	Name:   "Color",
}

var SampleCheckDuplicateResult = &CheckDuplicateResult{
	Object:      constants.ObjectTypeCheckDuplicateResult,
	IsDuplicate: true,
	Message:     new("This invoice number INV-001 already exists"),
}

var SampleChildAccount = &ChildAccount{
	ID:     SampleChildAccountRelationID,
	Object: constants.ObjectTypeChildAccount,
	Account: &Account{
		ID:     SampleAccountID,
		Object: constants.ObjectTypeAccount,
		Name:   "Child Customer Inc",
	},
	ExternalNumber: new(SampleChildAccountExternalNumber),
	Email:          new("support@childcustomer.com"),
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleCompleteRegistrationResponse = &CompleteRegistrationResponse{
	ID:     SampleAccountID,
	Object: constants.ObjectTypeAccount,
}

var SampleComputedQuantity = &ComputedQuantity{
	Object:       constants.ObjectTypeComputedQuantity,
	Value:        "1200",
	DisplayValue: "1,200 " + SampleUnitAbbreviation,
}

var SampleComputedRate = &ComputedRate{
	Object:       constants.ObjectTypeComputedRate,
	Value:        SampleRateValue,
	DisplayValue: "$25.50 / " + SampleUnitAbbreviation,
}

var SampleConfirmPaymentResponse = &ConfirmPaymentResponse{
	Object:          constants.ObjectTypeConfirmPaymentResponse,
	Status:          "succeeded",
	PaymentMethodID: new("pm_1QXmZ2AbCdEfGhIjKlMnOpQr"),
}

var SampleConsumption = &Consumption{
	ID:            SampleConsumptionID,
	Object:        constants.ObjectTypeConsumption,
	Quantity:      SampleQuantity,
	WasteQuantity: SampleQuantity,
	ConsumedItem:  SampleItem,
	Instructions:  &sampleConsumptionInstructions,
	CreatedAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:     timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleContactMatch = &ContactMatch{
	ID:           SampleContactMatchID,
	Object:       constants.ObjectTypeContactMatch,
	Relationship: constants.ContactRelationshipCustomer,
	Email:        "buyer@acme-co.example",
	AccountUser:  SampleAccountUser,
	Account:      SampleAccount,
}

var SampleConversation = &Conversation{
	ID:            SampleConversationID,
	Object:        constants.ObjectTypeConversation,
	Type:          constants.ConversationTypeDM,
	Audience:      constants.ConversationAudienceInternal,
	Status:        constants.ConversationStatusActive,
	LegalHold:     constants.LegalHoldStatusReleased,
	Participants:  NewList([]ConversationParticipant{*SampleConversationParticipant}, PageInfo{}),
	Unread:        2,
	LastMessageAt: timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	LastMessage: &Message{
		ID:         SampleMessageID,
		Object:     constants.ObjectTypeChatMessage,
		Kind:       constants.MessageKindChat,
		Status:     constants.MessageStatusSent,
		Visibility: constants.MessageVisibilityInternal,
		Channel:    constants.MessageChannelMessage,
		Sequence:   42,
		Body:       new("Sounds good — shipping it today."),
		Sender:     NewActor(SampleAccountUserID, constants.ActorTypeUser, new("Jie Yan"), nil),
		CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
	},
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleConversationLink = &ConversationLink{
	ID:           SampleConversationLinkID,
	Object:       constants.ObjectTypeConversationLink,
	Conversation: SampleConversation,
	Resource:     NewEntity(SampleSalesOrderID, constants.ObjectTypeSalesOrder, new("Order #1042"), nil),
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleConversationParticipant = &ConversationParticipant{
	ID:            SampleConversationParticipantID,
	Object:        constants.ObjectTypeConversationParticipant,
	Type:          constants.ParticipantTypeUser,
	Actor:         NewActor(SampleAccountUserID, constants.ActorTypeUser, new("Jie Yan"), nil),
	Role:          constants.ParticipantRoleMember,
	Membership:    constants.ParticipantMembershipActive,
	Notifications: constants.ParticipantNotificationsUnmuted,
	ReadCursor:    ReadCursor{Object: constants.ObjectTypeReadCursor, Sequence: 12},
}

var SampleCreateSessionResponse = &CreateSessionResponse{
	ID:     SampleRegistrationSessionID,
	Object: constants.ObjectTypeRegistrationSession,
}

var SampleCreateUserResponse = &CreateUserResponse{
	ID:     SampleUserID,
	Object: constants.ObjectTypeUser,
}

var SampleCreatedAPIKey = &CreatedAPIKey{
	Object:       constants.ObjectTypeCreatedAPIKey,
	APIKeySecret: SampleProdAPIKeyValue,
	APIKeyInfo:   *SampleAPIKey,
}

var SampleCreatedBy = &CreatedBy{
	Object:   constants.ObjectTypeCreatedBy,
	Relation: constants.CreatedByRelationInternal,
	Actor:    SampleActor,
}

var SampleCurrencyUnit = newSampleUnit("US Dollar", "$", constants.UnitTypeCurrency)

var SampleCustomer = &Customer{
	ID:               SampleCustomerID,
	Object:           constants.ObjectTypeCustomer,
	Name:             SampleCustomerName,
	Number:           SampleCustomerNumber,
	Status:           constants.AccountStatusCodeNormal,
	EDIStatus:        constants.EDIStatusDisabled,
	RelationshipType: constants.CustomerRelationshipTypeStandalone,
	CommissionPolicy: constants.CommissionPolicyApplied,
	Note:             &sampleCustomerNote,
	CreditLimit:      SampleQuantity,
	ContactInfo: &CustomerContactInfo{
		Object: constants.ObjectTypeCustomerContactInfo,
		Email:  &sampleCustomerEmail,
		Phone:  &sampleCustomerPhone,
		URL:    &sampleCustomerURL,
	},
	FreightPreferences: &CustomerFreightPreferences{
		Object:         constants.ObjectTypeCustomerFreightPreferences,
		Status:         constants.FreightPolicyBilled,
		Carrier:        SampleCarrier,
		ServiceLevel:   SampleServiceLevel,
		BillingType:    &sampleCarrierBillingType,
		BillingAccount: &sampleCarrierBillingAccount,
	},
	Defaults: &CustomerDefaults{
		Object:            constants.ObjectTypeCustomerDefaults,
		PaymentTerm:       SamplePaymentTerm,
		ShippingTerm:      SampleShippingTerm,
		Priority:          SamplePriority,
		SalesRep:          SampleAccountUser,
		FulfillmentPolicy: &sampleCustomerFulfillmentPolicy,
	},
	NotificationPreferences: &CustomerNotificationPreferences{
		Object:               constants.ObjectTypeCustomerNotificationPreferences,
		AcceptsInvoiceEmails: true,
	},
	BillToAddress: SampleAddress,
	ShipToAddress: SampleAddress,
	Type:          SampleAccountGroup,
	PriceGroups:   NewList([]AccountGroup{*SampleAccountGroup}, PageInfo{}),
	ParentAccount: nil,
	ChildAccounts: nil,
	CreatedAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:     timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleCustomerEntity = &Entity{
	ID:     SampleCustomerID,
	Object: constants.ObjectTypeEntity,
	Type:   constants.ObjectTypeCustomer,
	Name:   new(SampleCustomerName),
	Handle: new(SampleCustomerNumber),
}

var SampleCustomerLeadTime = &CustomerLeadTime{
	Object:   constants.ObjectTypeCustomerLeadTime,
	Customer: NewEntity(SampleCustomerID, constants.ObjectTypeCustomer, nil, nil),
	Days:     30,
	Source:   constants.LeadTimeSourceAccount,
}

var SampleCustomerPricingFinding = &CustomerPricingFinding{
	ID:             SampleAccountPriceID + ":" + SampleCustomerID,
	Object:         constants.ObjectTypeCustomerPricingFinding,
	AccountPriceID: SampleAccountPriceID,
	Reason:         constants.PricingFindingReasonBelowPeerMedianAndTargetMargin,
	Origin:         constants.AccountPriceOriginDirect,
	UnitPrice: &ComputedRate{
		Object:       constants.ObjectTypeComputedRate,
		Value:        "8.5000",
		DisplayValue: "$8.50 / " + SampleUnitAbbreviation,
	},
	PeerMedianPrice: &ComputedRate{
		Object:       constants.ObjectTypeComputedRate,
		Value:        "12.5000",
		DisplayValue: "$12.50 / " + SampleUnitAbbreviation,
	},
	BelowPeerMedianFraction: &samplePricingBelowPeer,
	GrossMargin:             &samplePricingGrossMargin,
}

var SampleCustomerProductLineAccess = &CustomerProductLineAccess{
	Object:       constants.ObjectTypeCustomerProductLineAccess,
	Customer:     SampleCustomer,
	ProductLines: NewList([]ProductLine{*SampleProductLine}, PageInfo{}),
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleDCLocation = &DCLocation{
	ID:       SampleDCLocationID,
	Object:   constants.ObjectTypeDCLocation,
	Location: "Warehouse A - Bay 3",
	Customer: &DCLocationCustomer{
		ID:     SampleCustomerID,
		Object: constants.ObjectTypeCustomer,
		Name:   SampleCustomerName,
	},
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleDelivery = &Delivery{
	ID:            SampleDeliveryID,
	Object:        constants.ObjectTypeDelivery,
	Number:        "DLV-001",
	PurchaseOrder: SamplePurchaseOrder,
	Status:        constants.DeliveryStatusAccepted,
	Lines:         NewList([]DeliveryLine{*SampleDeliveryLine}, PageInfo{}),
	AcceptedAt:    timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	CreatedAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:     timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleDeliveryLine = &DeliveryLine{
	ID:         SampleDeliveryLineID,
	Object:     constants.ObjectTypeDeliveryLine,
	Item:       SampleItem,
	Quantity:   SampleQuantity,
	UnitCost:   SampleRate,
	Location:   SampleLocation,
	Lot:        SampleLot,
	AcceptedAt: timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleDemandOverride = &DemandOverride{
	ID:             SampleDemandOverrideID,
	Object:         constants.ObjectTypeDemandOverride,
	ScopeType:      constants.DemandOverrideScopeItem,
	Scope:          NewEntity(SampleItemID, constants.ObjectTypeItem, nil, new(SampleItemSKU)),
	PeriodStartsAt: timeutil.TimestampToTime(sampleDemandOverridePeriodStart),
	PeriodEndsAt:   timeutil.TimestampToTime(sampleDemandOverridePeriodEnd),
	Adjustment:     constants.DemandOverrideAdjustmentDeltaUnits,
	Value:          5000,
	Unit:           newSampleUnit("Pair", "pr", constants.UnitTypeQuantity),
	Reason:         &sampleDemandOverrideReason,
	Note:           &sampleDemandOverrideNote,
	CreatedBy:      SampleActor,
	EffectiveAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	ExpiresAt:      timeutil.TimestampToTimePtr(sampleDemandOverrideExpiry),
	Status:         constants.ActivationStatusActive,
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleDemandOverrideType = &DemandOverrideType{
	ID:        SampleDemandOverrideTypeID,
	Object:    constants.ObjectTypeDemandOverrideType,
	Code:      constants.DemandOverrideAdjustmentDeltaUnits,
	Name:      "Delta Units",
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleDepartment = &Department{
	ID:               SampleDepartmentID,
	Object:           constants.ObjectTypeDepartment,
	Name:             SampleDepartmentName,
	Notes:            nil,
	Location:         SampleLocation,
	ScanningStations: NewList([]ScanningStation{*SampleScanningStation}, PageInfo{}),
	Machines:         NewList([]Machine{*SampleMachine}, PageInfo{}),
	LaborRate:        nil,
	CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:        timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleEDIRun = &EDIRun{
	ID:           SampleEDIRunID,
	Object:       constants.ObjectTypeEDIRun,
	CompletedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	HasSucceeded: true,
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleEachUnit = newSampleUnit("Each", "ea", constants.UnitTypeQuantity)

var SampleEmailContact = &EmailContact{
	ID:          SampleEmailContactID,
	Object:      constants.ObjectTypeEmailContact,
	AccountUser: SampleAccountUser,
}

var SampleEmailDomain = &EmailDomain{
	ID:         SampleEmailDomainID,
	Object:     constants.ObjectTypeEmailDomain,
	Domain:     "support.acme.com",
	Status:     "pending",
	DkimTokens: []string{"abc123._domainkey.support.acme.com", "def456._domainkey.support.acme.com"},
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleEmailInbox = &EmailInbox{
	ID:                 SampleEmailInboxID,
	Object:             constants.ObjectTypeEmailInbox,
	EmailDomain:        SampleEmailDomain,
	Address:            "support@acme.com",
	FromName:           &sampleEmailInboxFromName,
	Status:             "active",
	AgentConfig:        SampleAgentDefinition,
	AgentTriggerPolicy: &sampleEmailInboxTriggerPolicy,
	CreatedAt:          timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:          timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleEmailLog = &EmailLog{
	ID:         SampleEmailLogID,
	Object:     constants.ObjectTypeEmailLog,
	SendStatus: constants.EmailSendStatusSent,
	Recipients: []string{"customer@example.com"},
	Subject:    &sampleEmailLogSubject,
	Filename:   &sampleEmailLogFilename,
	SentBy:     SampleActor,
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleEnsureBillingCustomerResponse = &EnsureBillingCustomerResponse{
	Object:           constants.ObjectTypeEnsureBillingCustomerResponse,
	StripeCustomerID: SampleStripeCustomerID,
	Created:          true,
	BillingProfileID: &sampleBillingProfileID,
}

var SampleEnterpriseInquiry = &EnterpriseInquiry{
	ID:        SampleEnterpriseInquiryID,
	Object:    constants.ObjectTypeEnterpriseInquiry,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleEstimateRateResult = &EstimateRateResult{
	Object: constants.ObjectTypeEstimateRateResult,
	Rate:   42.5,
}

var SampleExportInventoryChangeLogsResponse = &ExportInventoryChangeLogsResponse{
	Object: constants.ObjectTypeList,
	Items:  []*InventoryChangeLog{SampleInventoryChangeLog},
	Count:  1,
}

var SampleExportItem = &ExportItem{
	ID:             SampleItemID,
	Object:         constants.ObjectTypeItem,
	SKU:            SampleItemSKU,
	Description:    &sampleDescription,
	Notes:          nil,
	ItemTypeCode:   constants.ItemTypeCodeProduct,
	CategoryName:   SampleItemCategoryName,
	OnHandQuantity: "100.000000000000000000000000000000",
	OnHandUnit:     SampleUnit,
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleExportItemsResponse = &ExportItemsResponse{
	Object: constants.ObjectTypeList,
	Items:  []*ExportItem{SampleExportItem},
	Count:  1,
}

var SampleFreight = &Freight{
	Object:               constants.ObjectTypeFreight,
	Policy:               &sampleFreightPolicy,
	Carrier:              SampleCarrier,
	ServiceLevel:         SampleServiceLevel,
	BillingType:          &sampleFreightBillingType,
	BillingAccountNumber: &sampleFreightBillingAccountNumber,
}

var SampleFrequentlyOrderedProduct = &FrequentlyOrderedProduct{
	Object:     constants.ObjectTypeFrequentlyOrderedProduct,
	Item:       SampleItem,
	Unit:       newSampleUnit(SampleUnitName, SampleUnitAbbreviation, constants.UnitTypeMass),
	OrderCount: 42,
}

var SampleFulfillmentRecommendation = &FulfillmentRecommendation{
	Object:                     constants.ObjectTypeFulfillmentRecommendation,
	Item:                       NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSettingsSKU),
	SKU:                        sampleScheduleSettingsSKU,
	ProductLine:                NewEntity(SampleProductLineID, constants.ObjectTypeProductLine, nil, nil),
	CurrentPolicy:              constants.FulfillmentPolicyMakeToStock,
	RecommendedPolicy:          constants.FulfillmentPolicyMakeToOrder,
	Changes:                    true,
	Reason:                     constants.FulfillmentRecommendationReasonLumpyDemand,
	AverageDemandInterval:      3,
	CoefficientOfVariation:     1.8,
	TopCustomerSharePct:        95,
	TopCustomerName:            &sampleTopCustomerName,
	DemandWeightedLeadTimeDays: 90,
	AnnualCOGS:                 4000,
	MonthsSinceLastSale:        1,
	MixedStreamSharePct:        95,
}

var SampleHubspotCompanyReview = &HubspotCompanyReview{
	ID:       SampleHubspotCompanyReviewID,
	Object:   constants.ObjectTypeHubspotCompanyReview,
	Job:      SampleHubspotSyncJob,
	Customer: SampleCustomer,
	Candidates: NewList([]HubspotCompanyCandidate{
		{Object: constants.ObjectTypeHubspotCompanyCandidate, HubspotID: "12345", Name: "Acme Manufacturing", Domain: "acme.com"},
		{Object: constants.ObjectTypeHubspotCompanyCandidate, HubspotID: "67890", Name: "Acme Mfg Inc", Domain: "acme.com"},
	}, PageInfo{}),
	Status:    constants.HubspotCompanyReviewStatusPending,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleHubspotSyncJob = &HubspotSyncJob{
	ID:             SampleHubspotSyncJobID,
	Object:         constants.ObjectTypeHubspotSyncJob,
	Status:         constants.HubspotSyncJobStatusReviewPending,
	GoLiveCutoffAt: &sampleHubspotGoLiveCutoffAt,
	Report: &HubspotSyncReport{
		Object:             constants.ObjectTypeHubspotSyncReport,
		CustomersTotal:     120,
		CompaniesConfident: 80,
		CompaniesAmbiguous: 12,
		CompaniesToCreate:  28,
		ContactsWithEmail:  95,
	},
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleHubspotSyncRecord = &HubspotSyncRecord{
	ID:           SampleHubspotSyncRecordID,
	Object:       constants.ObjectTypeHubspotSyncRecord,
	AugnoType:    constants.HubspotSyncRecordAugnoTypeCustomer,
	AugnoID:      SampleCustomer.ID,
	AugnoName:    SampleCustomer.Name,
	HubspotType:  constants.HubspotSyncRecordHubspotTypeCompanies,
	HubspotID:    "12345",
	LastSyncedAt: &sampleHubspotSyncRecordSyncedAt,
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleInventoryChangeLog = &InventoryChangeLog{
	ID:                         SampleInventoryChangeLogID,
	Object:                     constants.ObjectTypeInventoryChangeLog,
	ActionTypeCode:             constants.InventoryActionTypeScan,
	Quantity:                   SampleQuantity,
	Item:                       SampleItem,
	ResponsibleUser:            SampleUser,
	ResponsibleScanningStation: SampleScanningStation,
	CreatedAt:                  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:                  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleInventoryItem = &InventoryItem{
	Object:   constants.ObjectTypeInventoryItem,
	Item:     *SampleItem,
	Quantity: SampleQuantity,
}

var SampleInvoice = &Invoice{
	ID:       SampleInvoiceID,
	Object:   constants.ObjectTypeInvoice,
	Number:   "INV-001",
	Note:     &sampleInvoiceNote,
	Customer: SampleCustomer,
	Order:    SampleSalesOrder,
	Shipment: &Shipment{
		ID:        SampleShipmentID,
		Object:    constants.ObjectTypeShipment,
		Number:    SampleShipmentNumber,
		Status:    constants.ShipmentStatusShipped,
		Priority:  SamplePriorityCode,
		CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
	},
	LineCount:            3,
	BillingAddress:       SampleAddress,
	PriorityCode:         constants.PriorityCodeNormal,
	PaymentTerm:          SamplePaymentTerm,
	PaymentStatus:        constants.InvoicePaymentStatusUnpaid,
	IsEdiSent:            false,
	HasBeenSent:          true,
	TotalInvoiced:        "1234.56",
	AcceptsInvoiceEmails: true,
	CustomerIsEdiEnabled: false,
	Lines:                NewList([]InvoiceLine{*SampleInvoiceLine}, PageInfo{}),
	Allocations:          NewList([]InvoiceAllocation{*SampleInvoiceAllocation}, PageInfo{}),
	Related:              &InvoiceRelated{Object: constants.ObjectTypeInvoiceRelated},
	CreatedAt:            timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:            timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleInvoiceAllocation = &InvoiceAllocation{
	ID:          SampleInvoiceAllocationID,
	Object:      constants.ObjectTypeInvoiceAllocation,
	Transaction: SampleTransactionDetail,
	Note:        &sampleInvoiceAllocationNote,
	Amount: &Quantity{
		ID:           SampleQuantityID,
		Object:       constants.ObjectTypeQuantity,
		Value:        "500.000000000000000000000000000000",
		DisplayValue: "$500.00",
		Unit:         newSampleUnit("US Dollar", "$", constants.UnitTypeCurrency),
	},
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleInvoiceForPayment = &InvoiceForPayment{
	ID:              SampleInvoiceID,
	Object:          constants.ObjectTypeInvoiceForPayment,
	Number:          "INV-001",
	CustomerPO:      &sampleInvoiceForPaymentCustomerPO,
	Customer:        SampleCustomer,
	IsParentAccount: true,
	ParentAccount:   SampleAccount,
	IsPrepaid:       false,
	BillingAddress:  SampleAddress,
	InvoiceTotal:    "1234.56",
	IsPaidInFull:    false,
	Allocations:     NewList([]InvoiceAllocation{*SampleInvoiceAllocation}, PageInfo{}),
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleInvoiceLine = &InvoiceLine{
	ID:     SampleInvoiceLineID,
	Object: constants.ObjectTypeInvoiceLine,
	Quantity: &Quantity{
		ID:           SampleQuantityID,
		Object:       constants.ObjectTypeQuantity,
		Value:        "100.000000000000000000000000000000",
		DisplayValue: "100 lb",
		Unit:         newSampleUnit(SampleUnitName, SampleUnitAbbreviation, constants.UnitTypeMass),
	},
	UnitPrice: SampleRate,
	OrderLine: SampleSalesOrderLine,
	Item:      SampleItem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleItem = &Item{
	ID:           SampleItemID,
	Object:       constants.ObjectTypeItem,
	SKU:          SampleItemSKU,
	Description:  &sampleDescription,
	Notes:        nil,
	ItemTypeCode: constants.ItemTypeCodeProduct,
	Category:     SampleItemCategory,
	UnitValue:    SampleRate,
	UnitCost:     SampleRate,
	BurnRate:     SampleRate,
	Attributes:   NewList([]Attribute{*SampleAttribute}, PageInfo{}),
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleItemCategory = &ItemCategory{
	ID:         SampleItemCategoryID,
	Object:     constants.ObjectTypeItemCategory,
	Name:       SampleItemCategoryName,
	Notes:      &sampleItemCategoryNotes,
	Type:       constants.ItemCategoryTypeMaterial,
	Owner:      SampleOwnerSystem,
	Properties: NewList([]Property{*SampleProperty}, PageInfo{}),
	UnitGroup:  SampleUnitGroup,
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleItemCosts = &ItemCosts{
	Object:             constants.ObjectTypeItem,
	DirectMaterialCost: "5.000000000000000000000000000000",
	DirectLaborCost:    "3.000000000000000000000000000000",
	OverheadCost:       "2.000000000000000000000000000000",
	TotalCost:          "10.000000000000000000000000000000",
	Unit:               SampleUnit,
}

var SampleItemInventory = &ItemInventory{
	Object:             constants.ObjectTypeItemInventory,
	OnHand:             SampleComputedQuantity,
	Reserved:           SampleComputedQuantity,
	AvailableToPromise: SampleComputedQuantity,
	Short:              SampleComputedQuantity,
}

var SampleItemLotDefault = &ItemLotDefault{
	Object:      constants.ObjectTypeItemLotDefault,
	Item:        NewEntity(SampleItemID, constants.ObjectTypeItem, nil, nil),
	Quantity:    60,
	Source:      constants.ItemLotSourceDownstreamProductLine,
	ProductLine: NewEntity(SampleProductLineID, constants.ObjectTypeProductLine, nil, nil),
}

var SampleItemTrends = &ItemTrends{
	Object:    constants.ObjectTypeItem,
	TrendType: "on_hand",
	Points: NewList([]ItemTrendPoint{
		{
			Object:     constants.ObjectTypeItemTrendPoint,
			OccurredAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
			Value:      "100.000000000000000000000000000000",
		},
	}, PageInfo{}),
}

var SampleJob = &Job{
	ID:           SampleJobID,
	Object:       constants.ObjectTypeJob,
	Type:         constants.JobTypeBulkCreate,
	ResourceType: new(constants.ObjectTypeProductionRun),
	Status:       constants.JobStatusCompleted,
	Results: NewList([]JobResult{{
		Object:   constants.ObjectTypeJobResult,
		Index:    0,
		Status:   constants.JobResultStatusCreated,
		Resource: NewEntity(SampleProductionRunID, constants.ObjectTypeProductionRun, nil, nil),
		SubResources: NewList([]Entity{
			*NewEntity(SampleBatchID, constants.ObjectTypeBatch, nil, nil),
		}, PageInfo{}),
	}}, PageInfo{}),
	StartedAt:   timeutil.TimestampToTimePtr(sampleCreatedAtTimestamp),
	CompletedAt: timeutil.TimestampToTimePtr(sampleCreatedAtTimestamp),
	CreatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleJobExport = NewJobExport("https://files.openmrp.ai/exports/" + SampleAccountID + "/production_runs/" + SampleJobID + "/production_runs_20260817.xlsx?X-Amz-Signature=example")

var SampleJobResult = &SampleJob.Results.Data[0]

var SampleLocation = &Location{
	ID:       SampleLocationID,
	Object:   constants.ObjectTypeLocation,
	Name:     SampleLocationName,
	TypeCode: SampleLocationTypeCode,
	Parent:   nil,
	Children: NewList([]Location{
		{
			ID:        SampleLocationChildID,
			Object:    constants.ObjectTypeLocation,
			Name:      "Shelf A1",
			TypeCode:  SampleLocationTypeCode,
			CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
			UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
		},
	}, PageInfo{}),
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleLocationType = &LocationType{
	ID:        SampleLocationTypeID,
	Object:    constants.ObjectTypeLocationType,
	Code:      SampleLocationTypeCode,
	Name:      SampleLocationTypeName,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleLot = &Lot{
	ID:        SampleLotID,
	Object:    constants.ObjectTypeLot,
	LotNumber: "LOT-001",
}

var SampleMachine = &Machine{
	ID:           SampleMachineID,
	Object:       constants.ObjectTypeMachine,
	Name:         SampleMachineName,
	SerialNumber: SampleMachineSerialNumber,
	Notes:        &sampleMachineNotes,
	Department:   nil,
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleMachineDowntimeEvent = &MachineDowntimeEvent{
	ID:         SampleMachineDowntimeEventID,
	Object:     constants.ObjectTypeMachineDowntimeEvent,
	Machine:    SampleMachine,
	Department: SampleDepartment,
	Reason: &MachineDowntimeReasonSummary{
		Object:    constants.ObjectTypeMachineDowntimeReason,
		Code:      constants.MachineDowntimeReasonCodeBreakdown,
		Name:      &sampleDowntimeReasonName,
		OeeBucket: &sampleDowntimeOeeBucket,
	},
	StartedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	EndedAt:         timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	DurationSeconds: &sampleDowntimeDuration,
	ShiftDate:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	ShiftCode:       &sampleDowntimeShiftCode,
	Item:            SampleItem,
	ProductionRun:   NewEntity(SampleProductionRunID, constants.ObjectTypeProductionRun, nil, nil),
	Batch:           NewEntity(SampleBatchID, constants.ObjectTypeBatch, nil, nil),
	ScheduleLine:    NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
	Note:            &sampleDowntimeNote,
	ReportedBy:      SampleActor,
	Source:          constants.MachineDowntimeSourceManual,
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleMachineDowntimeReason = &MachineDowntimeReason{
	ID:             SampleMachineDowntimeReasonID,
	Object:         constants.ObjectTypeMachineDowntimeReason,
	Code:           constants.MachineDowntimeReasonCodeBreakdown,
	Name:           "Breakdown",
	OeeBucket:      constants.OeeBucketAvailability,
	PlanningStatus: constants.DowntimePlanningStatusUnplanned,
	SortOrder:      10,
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleMachineStatus = &MachineStatus{
	Object:              constants.ObjectTypeMachineStatus,
	Machine:             NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleMachineStatusMachineName, nil),
	Department:          NewEntity(SampleDepartmentID, constants.ObjectTypeDepartment, new(SampleDepartmentName), nil),
	Status:              constants.MachineWorkStatusRunning,
	WeekPlannedQuantity: 600,
	WeekScannedQuantity: 120,
	WeekPlannedRunHours: 5,
	Unit:                &sampleMachineStatusUnit,
	Current: &MachineCampaign{
		ScheduleLine:       NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
		Item:               NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleMachineStatusSKU),
		SKU:                sampleMachineStatusSKU,
		WeekStartDate:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		PlannedQuantity:    360,
		ScannedQuantity:    120,
		RemainingQuantity:  240,
		Unit:               &sampleMachineStatusUnit,
		ReleasedBatchCount: 6,
		ScannedBatchCount:  2,
		PlannedRunHours:    3,
		Status:             constants.ProductionScheduleLineStatusReleased,
		ProductionRun:      NewEntity(SampleProductionRunID, constants.ObjectTypeProductionRun, nil, nil),
	},
	Next: &MachineCampaign{
		ScheduleLine:      NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
		Item:              NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleMachineStatusNextSKU),
		SKU:               sampleMachineStatusNextSKU,
		WeekStartDate:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		PlannedQuantity:   240,
		ScannedQuantity:   0,
		RemainingQuantity: 240,
		Unit:              &sampleMachineStatusUnit,
		PlannedRunHours:   2,
		Status:            constants.ProductionScheduleLineStatusPlanned,
	},
}

var SampleMaterial = &Material{
	ID:         SampleMaterialID,
	Object:     constants.ObjectTypeMaterial,
	Item:       SampleItem,
	OrderPoint: SampleQuantity,
	LeadTime:   SampleQuantity,
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleMessage = &Message{
	ID:           SampleMessageID,
	Object:       constants.ObjectTypeChatMessage,
	Kind:         constants.MessageKindChat,
	Status:       constants.MessageStatusSent,
	Visibility:   constants.MessageVisibilityInternal,
	Channel:      constants.MessageChannelMessage,
	Conversation: SampleConversation,
	Sequence:     42,
	Body:         new("Sounds good — shipping it today."),
	Sender:       NewActor(SampleAccountUserID, constants.ActorTypeUser, new("Jie Yan"), nil),
	Author:       NewActor(SampleAccountUserID, constants.ActorTypeUser, new("Jie Yan"), nil),
	Attachments:  NewList([]MessageAttachment{*SampleMessageAttachment}, PageInfo{}),
	Resource:     NewEntity(SampleSalesOrderID, constants.ObjectTypeSalesOrder, new("Order #1042"), nil),
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleMessageAttachment = &MessageAttachment{
	ID:          SampleMessageAttachmentID,
	Object:      constants.ObjectTypeMessageAttachment,
	Kind:        constants.MessageAttachmentKindImage,
	Filename:    new("diagram.png"),
	ContentType: new("image/png"),
	SizeBytes:   new(int64(48213)),
	URL:         new("https://chat-bucket.s3.amazonaws.com/chat/ac/cv/mgah/diagram.png?X-Amz-Signature=..."),
	CreatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleMessageResource = &MessageResource{
	Object:  constants.ObjectTypeMessage,
	Message: "Operation completed successfully.",
}

var SampleMessagingBlock = &MessagingBlock{
	ID:          SampleMessagingBlockID,
	Object:      constants.ObjectTypeMessagingBlock,
	BlockedUser: SampleAccountUser,
	CreatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleMessagingGroup = &MessagingGroup{
	ID:        SampleMessagingGroupID,
	Object:    constants.ObjectTypeMessagingGroup,
	Name:      "Operations Team",
	Members:   NewList([]MessagingGroupMember{*SampleMessagingGroupMember}, PageInfo{}),
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleMessagingGroupMember = &MessagingGroupMember{
	ID:     SampleMessagingGroupMemberID,
	Object: constants.ObjectTypeMessagingGroupMember,
	Actor:  NewActor(SampleAccountUserID, constants.ActorTypeUser, new("Jie Yan"), nil),
}

var SampleNotification = &Notification{
	ID:        SampleNotificationID,
	Object:    constants.ObjectTypeNotification,
	Category:  constants.NotificationCategoryOrderUpdated,
	Status:    constants.NotificationStatusUnseen,
	Title:     "Order updated",
	Body:      new("Order #1024 changed from estimate to confirmed."),
	Sender:    NewActor(SampleAccountUserID, constants.ActorTypeUser, new("Jie Yan"), nil),
	Resource:  NewEntity(SampleSalesOrderID, constants.ObjectTypeSalesOrder, new(SampleSalesOrderNumber), nil),
	Priority:  constants.NotificationPriorityNormal,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleNotificationPreference = &NotificationPreference{
	ID:           SampleNotificationPreferenceID,
	Object:       constants.ObjectTypeNotificationPreference,
	Category:     new(constants.NotificationCategoryChatMessage),
	InAppEnabled: true,
	EmailEnabled: true,
	PushEnabled:  false,
	Digest:       constants.NotificationDigestInstant,
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleNotificationSendResult = &NotificationSendResult{
	Object:   constants.ObjectTypeNotificationSendResult,
	Enqueued: 1,
}

var SampleNotificationUnreadCount = &NotificationUnreadCount{
	Object:        constants.ObjectTypeNotificationUnreadCount,
	Notifications: 3,
	Conversations: 0,
	Total:         3,
}

var SampleNotificationUnreadSummary = &NotificationUnreadSummary{
	Object: constants.ObjectTypeNotificationUnreadSummary,
	Total:  5,
	Accounts: NewList([]NotificationUnreadSummaryAccount{
		{Object: constants.ObjectTypeNotificationUnreadSummaryAccount, Account: NewEntity(SampleAccountID, constants.ObjectTypeAccount, nil, nil), Unread: 5},
	}, PageInfo{}),
}

var SampleOAuthResponse = &OAuthResponse{
	Object:   constants.ObjectTypeOAuthResponse,
	OAuthURL: "https://oauth.fedex.com/authorize?client_id=abc123&redirect_uri=https://www.openmrp.ai/carriers/oauth/callback",
}

var SampleOAuthStatusResponse = &OAuthStatusResponse{
	Object: constants.ObjectTypeOAuthStatusResponse,
	Status: constants.CarrierConnectionStatusConnected,
}

var SampleOpenBatchSummary = &OpenBatchSummary{
	Object:          constants.ObjectTypeOpenBatchSummary,
	DepartmentName:  "Production",
	Item:            SampleItem,
	ScanningStation: SampleScanningStation,
	Count:           "5.000000000000000000000000000000",
	Unit:            "kg",
}

var SampleOpenCreditEntry = &OpenCreditEntry{
	ID:              SampleOpenCreditEntryID,
	Object:          constants.ObjectTypeOpenCreditEntry,
	Number:          "TXN-001",
	OriginalAmount:  "1000.000000000000000000000000000000",
	AllocatedAmount: "500.000000000000000000000000000000",
	LeftoverAmount:  "500.000000000000000000000000000000",
	Customer: &AllocationCustomer{
		ID:     new(SampleCustomerID),
		Object: constants.ObjectTypeAllocationCustomer,
		Name:   SampleCustomerName,
	},
	TransactionType:     "payment",
	TransactionMethod:   new("check"),
	ResponsibleUserName: new(SampleUserName),
	Note:                new("Customer check deposited; partially applied."),
	InvoiceAllocations: NewList([]InvoiceAllocationEntry{
		{Object: constants.ObjectTypeInvoiceAllocationEntry, InvoiceNumber: "INV-001", Amount: "500.000000000000000000000000000000"},
	}, PageInfo{}),
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleOperatingCalendar = &OperatingCalendar{
	Object:     constants.ObjectTypeOperatingCalendar,
	ID:         SampleOperatingCalendarID,
	Code:       "default_ship",
	Name:       "Shipping days",
	Kind:       constants.OperatingCalendarKindShip,
	DaysOfWeek: "1111000",
	CutoffAt:   &sampleCalendarCutoffAt,
	Timezone:   &sampleCalendarTimezone,
	IsDefault:  true,
	CreatedAt:  sampleCalendarCreated,
	UpdatedAt:  sampleCalendarCreated,
}

var SampleOperatingCalendarClosure = &OperatingCalendarClosure{
	Object:              constants.ObjectTypeOperatingCalendarClosure,
	ID:                  SampleOperatingCalendarClosureID,
	OperatingCalendarID: SampleOperatingCalendarID,
	ClosedOn:            time.Date(2026, time.November, 26, 0, 0, 0, 0, time.UTC),
	Name:                "Thanksgiving Day",
	CreatedAt:           sampleCalendarCreated,
	UpdatedAt:           sampleCalendarCreated,
}

var SampleOrderDiscount = &OrderDiscount{
	ID:           SampleOrderDiscountID,
	Object:       constants.ObjectTypeOrderDiscount,
	Name:         "10% Off",
	Code:         "SAVE10",
	Percentage:   "10.000000000000000000000000000000",
	Amount:       "0.000000000000000000000000000000",
	DiscountType: constants.OrderDiscountTypePercentage,
	OrderCount:   5,
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleOrderNotificationRecipient = &OrderNotificationRecipient{
	Object:      constants.ObjectTypeOrderNotificationRecipient,
	AccountUser: SampleAccountUser,
	NotificationTypes: []constants.AccountRelationNotificationType{
		constants.AccountRelationNotificationTypeOrderAcknowledgement,
		constants.AccountRelationNotificationTypeInvoice,
	},
}

var SampleOwnerAccount = &Owner{
	Object: constants.ObjectTypeOwner,
	Type:   constants.OwnerTypeAccount,
	Account: &Account{
		ID:        SampleAccountID,
		Object:    constants.ObjectTypeAccount,
		Name:      SampleAccountName,
		CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
	},
}

var SampleOwnerSystem = &Owner{
	Object: constants.ObjectTypeOwner,
	Type:   constants.OwnerTypeSystem,
}

var SamplePackList = &PackList{
	Object:             constants.ObjectTypePackList,
	AccountName:        "Acme Manufacturing",
	AccountLogoURL:     &samplePackListLogoURL,
	SalesOrderNumber:   "000123",
	CustomerPO:         &samplePackListCustomerPO,
	ShipmentNumber:     SampleShipmentNumber,
	ShippedAt:          &samplePackListShippedAt,
	BillTo:             SamplePackListParty,
	ShipTo:             SamplePackListParty,
	ContactInformation: []string{"receiving@acme.example.com", "+1-614-555-0142"},
	Carrier:            &samplePackListCarrier,
	CarrierOption:      &samplePackListOption,
	Priority:           &samplePackListPriority,
	PaymentTerm:        &samplePackListTerm,
	SalesRep:           &samplePackListSalesRep,
	ShippingCases:      NewList([]PackListCase{*SamplePackListCase}, PageInfo{}),
	LineItems:          NewList([]PackListLineItem{*SamplePackListLineItem}, PageInfo{}),
	BackOrders:         NewList([]PackListBackOrder{*SamplePackListBackOrder}, PageInfo{}),
}

var SamplePackListBackOrder = &PackListBackOrder{
	Object:              constants.ObjectTypePackListBackOrder,
	LineItemNumber:      &samplePackListLineNumber,
	SKU:                 "WIDGET-RED",
	Description:         "Red Widget, 10mm",
	QuantityOrdered:     "50",
	QuantityShipped:     "20",
	QuantityBackOrdered: "30",
	Unit:                "each",
}

var SamplePackListCase = &PackListCase{
	Object:         constants.ObjectTypePackListCase,
	Number:         "CASE-001",
	Weight:         "12.5",
	WeightUnit:     "lb",
	TrackingNumber: &samplePackListTracking,
	Carrier:        &samplePackListCarrier,
}

var SamplePackListLineItem = &PackListLineItem{
	Object:         constants.ObjectTypePackListLineItem,
	LineItemNumber: &samplePackListLineNumber,
	SKU:            "WIDGET-BLUE",
	Description:    "Blue Widget, 10mm",
	Quantity:       "24",
	Unit:           "each",
}

var SamplePackListParty = &PackListParty{
	Object:      constants.ObjectTypePackListParty,
	Name:        "Acme Manufacturing",
	StreetLine1: &samplePackListBillStreet1,
	Locality:    &samplePackListBillCity,
	State:       &samplePackListBillState,
	PostalCode:  &samplePackListBillZip,
	Country:     &samplePackListBillCountry,
	Phone:       &samplePackListBillPhone,
}

var SamplePart = &Part{
	ID:        SamplePartID,
	Object:    constants.ObjectTypePart,
	Item:      SampleItem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePaymentTerm = &PaymentTerm{
	ID:        SamplePaymentTermID,
	Object:    constants.ObjectTypePaymentTerm,
	Name:      SamplePaymentTermName,
	Status:    constants.PaymentTermStatusActive,
	Owner:     SampleOwnerSystem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePermission = &Permission{
	ID:                  SamplePermissionID,
	Object:              constants.ObjectTypePermission,
	Code:                "customers:read",
	Name:                "Read Customers",
	Description:         nil,
	PermissionGroupCode: "customers",
	CreatedAt:           timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:           timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePermissionGroup = &PermissionGroup{
	ID:          SamplePermissionGroupID,
	Object:      constants.ObjectTypePermissionGroup,
	Code:        "customers",
	Name:        "Customers",
	Description: nil,
	Permissions: NewList([]Permission{*SamplePermission}, PageInfo{}),
	Owner:       SampleOwnerSystem,
	CreatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:   timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePick = &Pick{
	ID:        SamplePickID,
	Object:    constants.ObjectTypePick,
	Number:    SamplePickNumber,
	Customer:  SampleCustomer,
	Priority:  SamplePriorityCode,
	ShipTo:    SampleAddress,
	LineCount: 1,
	Totals: &PickTotals{
		Object: constants.ObjectTypePickTotals,
		Picked: PickStageTotal{Object: constants.ObjectTypePickStageTotal, Completion: 1},
		Packed: PickStageTotal{Object: constants.ObjectTypePickStageTotal, Completion: 0.5},
	},
	Lines:          NewList([]PickLine{*SamplePickLine}, PageInfo{}),
	Related:        &PickRelated{Object: constants.ObjectTypePickRelated},
	PromisedAt:     timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
	ShipByDate:     timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
	LeadTimeDays:   &samplePickLeadTimeDays,
	LeadTimeSource: &samplePickLeadTimeSource,
	TransitDays:    &samplePickTransitDays,
	TransitSource:  &samplePickTransitSource,
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePickLine = &PickLine{
	ID:              SamplePickLineID,
	Object:          constants.ObjectTypePickLine,
	Item:            SampleItem,
	Quantity:        SampleQuantity,
	OrderedQuantity: SampleQuantity,
	SalesOrderLine:  SampleSalesOrderLine,
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePickShipmentsResponse = &PickShipmentsResponse{
	Object:          constants.ObjectTypePickShipmentsResponse,
	ShipmentNumbers: []string{"SH-001", "SH-002"},
	Count:           2,
}

var SamplePlanChangeProration = &PlanChangeProration{
	Object:                     constants.ObjectTypePlanChangeProration,
	NetAmount:                  4900,
	FormattedNetAmount:         "$49.00",
	MonthlyBillAmount:          4900,
	FormattedMonthlyBillAmount: "$49.00",
	LineItems: NewList([]PlanChangeLineItem{
		{Object: constants.ObjectTypePlanChangeLineItem, Description: "Professional plan \u2014 1 seat(s) \u00d7 $49.00/mo", Amount: 4900},
	}, PageInfo{}),
	IsEstimate: true,
}

var SamplePlanLimitInvoices = &PlanLimit{
	Object: constants.ObjectTypePlanLimit,
	Key:    "invoices_maximum",
	Value:  new(10000),
}

var SamplePlanLimitSandboxes = &PlanLimit{
	Object: constants.ObjectTypePlanLimit,
	Key:    "sandboxes_maximum",
	Value:  new(1),
}

var SamplePlanLimitSeats = &PlanLimit{
	Object: constants.ObjectTypePlanLimit,
	Key:    "seats_maximum",
	Value:  new(5),
}

var SamplePortalDomain = &PortalDomain{
	ID:     SamplePortalDomainID,
	Object: constants.ObjectTypePortalDomain,
	Domain: "shop.acme.com",
	Status: constants.PortalDomainStatusPending,
	DNSRecords: NewList([]DNSRecord{
		{
			Object: constants.ObjectTypeDNSRecord,
			Type:   constants.DNSRecordTypeCNAME,
			Name:   "shop.acme.com",
			Value:  "cname.vercel-dns.com",
			Reason: constants.DNSRecordReasonRouting,
		},
	}, PageInfo{}),
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePricingPlanFree = &PricingPlan{
	ID:           SamplePlanTypeIDFree,
	Object:       constants.ObjectTypePricingPlan,
	Name:         "Free",
	PlanTypeCode: constants.PublicPlanCodeFree,
	PricePerSeat: 0,
	PricePerMonth: func() *float64 {
		v := 0.0
		return &v
	}(),
	SeatMinimum: new(1),
	Limits: NewList([]PlanLimit{
		{Object: constants.ObjectTypePlanLimit, Key: "sandboxes_maximum", Value: new(1)},
		{Object: constants.ObjectTypePlanLimit, Key: "seats_maximum", Value: new(1)},
		{Object: constants.ObjectTypePlanLimit, Key: "invoices_maximum", Value: new(100)},
		{Object: constants.ObjectTypePlanLimit, Key: "batches_maximum", Value: new(10000)},
	}, PageInfo{}),
	DisplayFeatures: []string{
		"1 sandbox environment",
		"Up to 100 invoices per month",
		"Basic support",
	},
	DisplayOrder:  1,
	IsHighlighted: false,
	ButtonText:    "Get Started",
	IncludesPreviousPlan: func() *string {
		v := ""
		return &v
	}(),
}

var SamplePricingPlanPro = &PricingPlan{
	ID:           SamplePlanTypeIDPro,
	Name:         "Professional",
	Object:       constants.ObjectTypePricingPlan,
	PlanTypeCode: constants.PublicPlanCodePro,
	PricePerSeat: 49,
	PricePerMonth: func() *float64 {
		v := 147.0
		return &v
	}(),
	SeatMinimum: new(3),
	Limits: NewList([]PlanLimit{
		{Object: constants.ObjectTypePlanLimit, Key: "sandboxes_maximum", Value: new(999)},
		{Object: constants.ObjectTypePlanLimit, Key: "seats_maximum", Value: new(999)},
		{Object: constants.ObjectTypePlanLimit, Key: "invoices_maximum", Value: new(999)},
		{Object: constants.ObjectTypePlanLimit, Key: "batches_maximum", Value: new(10000)},
	}, PageInfo{}),
	DisplayFeatures: []string{
		"Unlimited sandbox environments",
		"Unlimited team seats",
		"Unlimited invoices",
		"Dedicated support",
		"Custom integrations",
	},
	DisplayOrder:  3,
	IsHighlighted: false,
	ButtonText:    "Contact Sales",
	IncludesPreviousPlan: func() *string {
		v := "Starter"
		return &v
	}(),
}

var SamplePricingPlanStarter = &PricingPlan{
	ID:           SamplePlanTypeIDStarter,
	Object:       constants.ObjectTypePricingPlan,
	Name:         "Starter",
	PlanTypeCode: constants.PublicPlanCodeStarter,
	PricePerSeat: 19,
	PricePerMonth: func() *float64 {
		v := 19.0
		return &v
	}(),
	SeatMinimum: new(1),
	Limits: NewList([]PlanLimit{
		{Object: constants.ObjectTypePlanLimit, Key: "sandboxes_maximum", Value: new(3)},
		{Object: constants.ObjectTypePlanLimit, Key: "seats_maximum", Value: new(5)},
		{Object: constants.ObjectTypePlanLimit, Key: "invoices_maximum", Value: new(10000)},
		{Object: constants.ObjectTypePlanLimit, Key: "batches_maximum", Value: new(10000)},
	}, PageInfo{}),
	DisplayFeatures: []string{
		"3 sandbox environments",
		"Up to 5 team seats",
		"Unlimited invoices",
		"Priority email support",
	},
	DisplayOrder:  2,
	IsHighlighted: true,
	ButtonText:    "Get Started",
	IncludesPreviousPlan: func() *string {
		v := "Free"
		return &v
	}(),
}

var SamplePriority = &Priority{
	ID:        SamplePriorityID,
	Object:    constants.ObjectTypePriority,
	Code:      SamplePriorityCode,
	Name:      SamplePriorityName,
	Owner:     SampleOwnerSystem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProduct = &Product{
	ID:               SampleProductID,
	Object:           constants.ObjectTypeProduct,
	Type:             SampleProductTypeCode,
	PortalVisibility: constants.CustomerPortalVisibilityVisible,
	ProductLine:      SampleProductLine,
	Item:             SampleItem,
	CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:        timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductLine = &ProductLine{
	ID:               SampleProductLineID,
	Object:           constants.ObjectTypeProductLine,
	Name:             SampleProductLineName,
	Description:      &sampleProductLineDescription,
	Notes:            &sampleProductLineNotes,
	CommissionPolicy: constants.CommissionPolicyExempt,
	FreightPolicy:    constants.FreightPolicyBilled,
	Owner:            SampleOwnerSystem,
	UnitGroup:        SampleUnitGroup,
	DefaultLot:       SampleQuantity,
	CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:        timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductType = &ProductType{
	ID:        SampleProductTypeID,
	Object:    constants.ObjectTypeProductType,
	Name:      SampleProductTypeName,
	Code:      SampleProductTypeCode,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionFlow = &ProductionFlow{
	Object: constants.ObjectTypeProductionFlow,
	Steps:  NewList([]ProductionFlowStep{SampleProductionFlowStep}, PageInfo{}),
}

var SampleProductionFlowConsumption = ProductionFlowConsumption{
	ID:            SampleConsumptionID,
	Object:        constants.ObjectTypeConsumption,
	ConsumedItem:  SampleItem,
	Quantity:      SampleQuantity,
	WasteQuantity: SampleQuantity,
	Instructions:  &sampleFlowInstructions,
	CreatedAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:     timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionFlowProduction = &ProductionFlowProduction{
	ID:           SampleProductionID,
	Object:       constants.ObjectTypeProduction,
	ProducedItem: SampleItem,
	Quantity:     SampleQuantity,
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionFlowStep = ProductionFlowStep{
	ID:              SampleProductionStepID,
	Object:          constants.ObjectTypeProductionStep,
	Name:            "Final Assembly",
	Notes:           &sampleProductionFlowStepNotes,
	Production:      SampleProductionFlowProduction,
	Consumptions:    NewList([]ProductionFlowConsumption{SampleProductionFlowConsumption}, PageInfo{}),
	InSteps:         NewList([]ProductionStep{}, PageInfo{}),
	OutSteps:        NewList([]ProductionStep{}, PageInfo{}),
	Machines:        NewList([]Machine{*SampleMachine}, PageInfo{}),
	Department:      SampleDepartment,
	ScanningStation: SampleScanningStation,
	LevelingFactor:  "1.000000000000000000000000000000",
	Allowances:      "0.000000000000000000000000000000",
	LaborRate:       SampleRate,
	LaborTime:       SampleRate,
	OverheadRate:    SampleRate,
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionOutput = &ProductionOutput{
	ID:           SampleProductionID,
	Object:       constants.ObjectTypeProduction,
	ProducedItem: SampleItem,
	Quantity:     SampleQuantity,
	CreatedAt:    timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:    timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionRun = &ProductionRun{
	ID:              SampleProductionRunID,
	Object:          constants.ObjectTypeProductionRun,
	Number:          "1",
	ResponsibleUser: SampleAccountUser,
	BatchCount:      3,
	StartedAt:       timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionRunReference = &ProductionRunReference{
	ID:     SampleProductionRunID,
	Object: constants.ObjectTypeProductionRun,
	Number: "PR-001",
}

var SampleProductionSchedule = &ProductionSchedule{
	ID:                SampleProductionScheduleID,
	Object:            constants.ObjectTypeProductionSchedule,
	Version:           3,
	Status:            constants.ProductionScheduleStatusPublished,
	Name:              new("May planning cycle"),
	PlanningAsOf:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	HorizonStartDate:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	HorizonEndDate:    timeutil.TimestampToTime(sampleHorizonEndTimestamp),
	HorizonWeeks:      13,
	FrozenWeeks:       1,
	FrozenThroughDate: timeutil.TimestampToTimePtr(sampleFrozenThroughTimestamp),
	DemandBasis:       constants.ScheduleDemandBasisTrailing12,
	GenerationSource:  constants.ScheduleGenerationSourceManual,
	SolverVersion:     "v1",
	SettingsSnapshot: map[string]any{
		"planning_horizon_weeks": 13,
		"frozen_weeks":           1,
		"capacity_headroom_pct":  0.9,
		"shifts_per_day":         2,
		"hours_per_shift":        7,
	},
	Diagnostics:           sampleScheduleDiagnostics,
	FrozenLineCount:       6,
	FrozenPlannedQuantity: 4320,
	GeneratedBy:           SampleActor,
	PublishedBy:           SampleActor,
	PublishedAt:           timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	CreatedAt:             timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:             timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionScheduleDerivedLine = &ProductionScheduleDerivedLine{
	ID:                 SampleProductionScheduleDerivedLineID,
	Object:             constants.ObjectTypeProductionScheduleDerivedLine,
	ProductionSchedule: NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	SourceLine:         NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
	ProductionStep:     NewEntity(SampleProductionStepID, constants.ObjectTypeProductionStep, new("Final Assembly"), nil),
	Department:         NewEntity(SampleDepartmentID, constants.ObjectTypeDepartment, new(SampleDepartmentName), nil),
	Item:               NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
	WeekIndex:          1,
	WeekStartDate:      timeutil.TimestampToTime(sampleWeekTwoStartTimestamp),
	Quantity:           600,
	PlannedUnit:        NewEntity(SampleUnitID, constants.ObjectTypeUnit, &samplePlannedUnitName, nil),
	ExplosionDepth:     1,
	OffsetWeeks:        1,
	Status:             constants.ProductionScheduleLineStatusPlanned,
	CreatedAt:          timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:          timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionScheduleDeviation = &ProductionScheduleDeviation{
	ID:                 SampleProductionScheduleDeviationID,
	Object:             constants.ObjectTypeProductionScheduleDeviation,
	ProductionSchedule: NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	Line:               NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
	DeviationType:      constants.ScheduleDeviationTypeQuantityChanged,
	FreezeStatus:       constants.ScheduleFreezeStatusFrozen,
	WeekIndex:          &sampleDeviationWeekIndex,
	Machine:            NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
	Item:               NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
	Before:             json.RawMessage(`{"planned_quantity":600,"planned_lots":10,"planned_run_hours":5}`),
	After:              json.RawMessage(`{"planned_quantity":900,"planned_lots":15,"planned_run_hours":7.5}`),
	DeltaQuantity:      300,
	DeltaRunHours:      2.5,
	Reason:             &sampleDeviationReasonCode,
	ReasonNote:         &sampleDeviationReasonNote,
	Actor:              SampleActor,
	CreatedAt:          timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleProductionScheduleFinishedPolicy = &ProductionScheduleFinishedPolicy{
	ID:                 SampleProductionScheduleFinishedPolicyID,
	Object:             constants.ObjectTypeProductionScheduleFinishedPolicy,
	ProductionSchedule: NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	Item:               NewEntity(SampleItemID, constants.ObjectTypeItem, nil, nil),
	SKU:                "MZ-CREW-BLK-L",
	GreigeItem:         NewEntity(SampleItemID, constants.ObjectTypeItem, nil, nil),
	GreigeSKU:          "MZ-GREIGE-CREW",
	AnnualDemand:       26000,
	WeeklyDemand:       500,
	SigmaWeekly:        130,
	SafetyStock:        524,
	ReorderPoint:       3524,
	OnHand:             3000,
	WeeksOfCover:       6,
	CreatedAt:          timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:          timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionScheduleFinishingLine = &ProductionScheduleFinishingLine{
	ID:                    SampleProductionScheduleFinishingLineID,
	Object:                constants.ObjectTypeProductionScheduleFinishingLine,
	ProductionSchedule:    NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	WeekIndex:             2,
	WeekStartDate:         timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	Item:                  NewEntity(SampleItemID, constants.ObjectTypeItem, nil, nil),
	SKU:                   "MZ-CREW-BLK-L",
	GreigeItem:            NewEntity(SampleItemID, constants.ObjectTypeItem, nil, nil),
	GreigeSKU:             "MZ-GREIGE-CREW",
	Department:            NewEntity(SampleDepartmentID, constants.ObjectTypeDepartment, nil, nil),
	PlannedQuantity:       240,
	Unit:                  &sampleFinishingUnit,
	PlannedLots:           4,
	PlannedLotUnits:       60,
	PlannedRunHours:       19.2,
	GreigeConsumed:        240,
	FirmUnits:             120,
	ProjectedOnHandBefore: 180,
	ProjectedOnHandAfter:  420,
	Status:                constants.ProductionScheduleLineStatusPlanned,
	Source:                constants.ScheduleLineSourceSolver,
	CreatedAt:             timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:             timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionScheduleItemPolicy = &ProductionScheduleItemPolicy{
	ID:                      SampleProductionScheduleItemPolicyID,
	Object:                  constants.ObjectTypeProductionScheduleItemPolicy,
	ProductionSchedule:      NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	Item:                    NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
	FulfillmentPolicy:       constants.FulfillmentPolicyMakeToStock,
	PolicySource:            constants.FulfillmentPolicySourceProductLine,
	SKU:                     sampleScheduleSKU,
	Unit:                    NewEntity(SampleUnitID, constants.ObjectTypeUnit, &samplePlannedUnitName, nil),
	UnitAbbreviation:        &samplePlannedUnitAbbreviation,
	ProductionStep:          NewEntity(SampleProductionStepID, constants.ObjectTypeProductionStep, &sampleScheduleStepName, nil),
	PrimaryMachine:          NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
	AnnualDemand:            5200,
	WeeklyDemand:            100,
	SecondsPerUnit:          30,
	UnitCost:                4,
	SetupCost:               50,
	HoldingCost:             1,
	EOQUnits:                720,
	ConstraintLeadTimeWeeks: 1.3,
	FinishLeadTimeWeeks:     6,
	SigmaWeeklyPooled:       130,
	SigmaDownstreamSum:      180,
	SafetyStockPrimary:      244,
	SafetyStockDownstream:   524,
	ReorderPoint:            974,
	OrderUpTo:               1694,
	OnHandEchelon:           1450,
	OnHandGreige:            320,
	AverageGreigeInventory:  604,
	MaxGreigeInventory:      964,
	WeeksOfCover:            14.5,
	ProjectedOnHand:         sampleScheduleProjectedOnHand,
	ProjectedGreigeOnHand:   sampleScheduleProjectedGreigeOnHand,
	AnnualRunHours:          43.3,
	ABCClass:                &sampleABCClassA,
	Constraints:             []constants.SchedulePolicyConstraint{},
	CreatedAt:               timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:               timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionScheduleItemSetting = &ProductionScheduleItemSetting{
	ID:                  SampleProductionScheduleItemSettingID,
	Object:              constants.ObjectTypeProductionScheduleItemSetting,
	Item:                NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSettingsSKU),
	ParticipationStatus: constants.ParticipationStatusIncluded,
	LotMultipleUnits:    &sampleItemSettingLotMultiple,
	FulfillmentPolicy:   &sampleItemSettingPolicy,
	CreatedAt:           timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:           timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionScheduleLine = &ProductionScheduleLine{
	ID:                       SampleProductionScheduleLineID,
	Object:                   constants.ObjectTypeProductionScheduleLine,
	ProductionSchedule:       NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	WeekIndex:                0,
	WeekStartDate:            timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	Machine:                  NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
	ProductionStep:           NewEntity(SampleProductionStepID, constants.ObjectTypeProductionStep, &sampleScheduleStepName, nil),
	Department:               NewEntity(SampleDepartmentID, constants.ObjectTypeDepartment, new(SampleDepartmentName), nil),
	Item:                     NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
	PlannedQuantity:          720,
	PlannedUnit:              NewEntity(SampleUnitID, constants.ObjectTypeUnit, &samplePlannedUnitName, nil),
	PlannedUnitAbbreviation:  &samplePlannedUnitAbbreviation,
	PlannedLots:              12,
	PlannedLotUnits:          60,
	PlannedRunHours:          6,
	PlannedChangeoverMinutes: 25,
	SequenceIndex:            0,
	ProjectedOnHandBefore:    1450,
	ProjectedOnHandAfter:     2070,
	Status:                   constants.ProductionScheduleLineStatusReleased,
	Source:                   constants.ScheduleLineSourceSolver,
	FreezeStatus:             constants.ScheduleFreezeStatusFrozen,
	ProductionRun:            NewEntity(SampleProductionRunID, constants.ObjectTypeProductionRun, nil, nil),
	ReleasedBatchCount:       12,
	ScannedBatchCount:        4,
	ScannedQuantity:          240,
	CreatedAt:                timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:                timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionSchedulePreview = &ProductionSchedulePreview{
	Object:        constants.ObjectTypeProductionSchedulePreview,
	SolverVersion: "v1",
	PlanningAsOf:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	Policies: NewList([]SchedulePolicy{{
		Item:                    NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
		SKU:                     sampleScheduleSKU,
		FulfillmentPolicy:       constants.FulfillmentPolicyMakeToStock,
		PolicySource:            constants.FulfillmentPolicySourceProductLine,
		AnnualDemand:            5200,
		WeeklyDemand:            100,
		SecondsPerUnit:          30,
		UnitCost:                4,
		SetupCost:               50,
		HoldingCost:             1,
		EOQUnits:                720,
		ConstraintLeadTimeWeeks: 1.3,
		FinishLeadTimeWeeks:     6,
		SafetyStockPrimary:      244,
		SafetyStockDownstream:   524,
		ReorderPoint:            974,
		OrderUpTo:               1694,
		OnHandEchelon:           1450,
		OnHandGreige:            320,
		AverageGreigeInventory:  604,
		MaxGreigeInventory:      964,
		WeeksOfCover:            14.5,
		ABCClass:                &sampleABCClassA,
		AnnualRunHours:          43.3,
	}}, PageInfo{}),
	Campaigns: NewList([]ScheduleCampaign{{
		Item:      NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
		SKU:       sampleScheduleSKU,
		Machine:   NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
		WeekIndex: 0,
		Units:     720,
		Lots:      12,
		RunHours:  6,
	}}, PageInfo{}),
	Projections: NewList([]ScheduleProjection{{
		Item:         NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
		OnHandByWeek: sampleScheduleProjectedOnHand,
	}}, PageInfo{}),
	Diagnostics: sampleScheduleDiagnostics,
}

var SampleProductionScheduleRegeneratePreview = &ProductionScheduleRegeneratePreview{
	Object:             constants.ObjectTypeProductionScheduleRegeneratePreview,
	ProductionSchedule: NewEntity(SampleProductionScheduleID, constants.ObjectTypeProductionSchedule, nil, nil),
	SolverVersion:      "v1",
	PlanningAsOf:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	Lines: NewList([]ScheduleDiffLine{
		{
			Change:           constants.ScheduleDiffChangeChanged,
			Item:             NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
			SKU:              sampleScheduleSKU,
			Machine:          NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
			WeekIndex:        2,
			CurrentQuantity:  600,
			ProposedQuantity: 720,
		},
		{
			Change:           constants.ScheduleDiffChangeAdded,
			Item:             NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
			SKU:              sampleScheduleSKU,
			Machine:          NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
			WeekIndex:        7,
			CurrentQuantity:  0,
			ProposedQuantity: 720,
		},
		{
			Change:           constants.ScheduleDiffChangeRemoved,
			Item:             NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
			SKU:              sampleScheduleSKU,
			Machine:          NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
			WeekIndex:        5,
			CurrentQuantity:  300,
			ProposedQuantity: 0,
			CurrentIsManual:  true,
		},
	}, PageInfo{}),
	AddedCount:           1,
	RemovedCount:         1,
	ChangedCount:         1,
	ManualLineCount:      1,
	DiscardedManualCount: 1,
}

var SampleProductionScheduleResourceSetting = &ProductionScheduleResourceSetting{
	ID:                  SampleProductionScheduleResourceSettingID,
	Object:              constants.ObjectTypeProductionScheduleResourceSetting,
	ScopeType:           constants.ScheduleResourceScopeDepartment,
	Scope:               NewEntity(SampleDepartmentID, constants.ObjectTypeDepartment, new(SampleDepartmentName), nil),
	ParticipationStatus: constants.ParticipationStatusIncluded,
	LeadTimeWeeks:       new(0.5),
	LeadTimeOffsetWeeks: 1,
}

var SampleProductionScheduleSettings = &ProductionScheduleSettings{
	Object:                         constants.ObjectTypeProductionScheduleSettings,
	ConstraintDepartment:           NewEntity(SampleDepartmentID, constants.ObjectTypeDepartment, new(SampleDepartmentName), nil),
	PlanningHorizonWeeks:           13,
	FrozenWeeks:                    1,
	WeekStartDay:                   1,
	DemandWindowMonths:             12,
	ForecastHistoryMonths:          24,
	ForecastMonths:                 12,
	DemandBasis:                    constants.ScheduleDemandBasisTrailing12,
	ForecastZ:                      1.645,
	ChangeoverAvgMinutes:           30,
	ChangeoverMinMinutes:           15,
	ChangeoverMaxMinutes:           90,
	ChangeoverLaborRate:            20,
	HoldingRatePct:                 0.25,
	ServiceLevelZ:                  1.645,
	FinishLeadTimeWeeks:            6,
	DefaultConstraintLeadTimeWeeks: 1.3,
	MaxWeeksSupply:                 12,
	MaxFlowDepth:                   10,
	ShiftsPerDay:                   2,
	HoursPerShift:                  7,
	WorkDaysPerWeek:                5,
	WeeksPerYear:                   52,
	CapacityHeadroomPct:            0.9,
	DefaultLotUnits:                60,
	DefaultCustomerLeadTimeDays:    30,
	DefaultFulfillmentPolicy:       constants.FulfillmentPolicyMakeToStock,
	CadenceStatus:                  constants.ActivationStatusActive,
	GenerationCron:                 &sampleGenerationCron,
	GenerationTimezone:             "America/New_York",
	AutoPublishStatus:              constants.ActivationStatusInactive,
	LastGeneratedAt:                timeutil.TimestampToTimePtr(sampleCreatedAtTimestamp),
	SettingsStatus:                 constants.SettingsStatusStored,
	CreatedAt:                      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:                      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProductionStep = &ProductionStep{
	ID:              SampleProductionStepID,
	Object:          constants.ObjectTypeProductionStep,
	Name:            "Final Assembly",
	Notes:           &sampleProductionStepNotes,
	LevelingFactor:  "1.000000000000000000000000000000",
	Allowances:      "0.000000000000000000000000000000",
	LaborRate:       SampleRate,
	LaborTime:       SampleRate,
	OverheadRate:    SampleRate,
	Production:      SampleProductionOutput,
	Consumptions:    NewList([]Consumption{*SampleConsumption}, PageInfo{}),
	Machines:        NewList([]Machine{*SampleMachine}, PageInfo{}),
	ScanningStation: SampleScanningStation,
	Department:      SampleDepartment,
	InSteps:         NewList([]ProductionStep{}, PageInfo{}),
	OutSteps:        NewList([]ProductionStep{}, PageInfo{}),
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleProperty = &Property{
	ID:         SamplePropertyID,
	Object:     constants.ObjectTypeProperty,
	Name:       SamplePropertyName,
	Attributes: NewList([]Attribute{*SampleAttribute}, PageInfo{}),
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePublicAccount = &PublicAccount{
	ID:                    SampleAccountID,
	Object:                constants.ObjectTypePublicAccount,
	Name:                  SampleAccountName,
	Slug:                  SampleAccountPortalSlug,
	DefaultBillingAddress: SampleAddress,
	SupportEmail:          new("support@acme.example.com"),
	LogoURL:               new("https://cdn.openmrp.ai/branding/abr_2rygb4fof28b/logo.png"),
	PortalDomain:          new("shop.acme.com"),
	FaviconURL:            new("https://cdn.openmrp.ai/branding/abr_2rygb4fof28b/favicon.png"),
}

var SamplePurchaseOrder = &PurchaseOrder{
	ID:                   SamplePurchaseOrderID,
	Object:               constants.ObjectTypePurchaseOrder,
	Number:               SamplePurchaseOrderNumber,
	Note:                 &samplePurchaseOrderNote,
	Status:               constants.SalesOrderStatusCodeEstimate,
	Priority:             SamplePriorityCode,
	AcknowledgmentStatus: constants.AcknowledgmentStatusNotSent,
	Supplier:             SampleSupplier,
	BillToAddress:        SampleAddress,
	ShipToAddress:        SampleAddress,
	Freight:              SampleFreight,
	PaymentTerm:          SamplePaymentTerm,
	ShippingTerm:         SampleShippingTerm,
	Lines:                NewList([]PurchaseOrderLine{*SamplePurchaseOrderLine}, PageInfo{}),
	LineCount:            1,
	Contacts:             NewList([]EmailContact{*SampleEmailContact}, PageInfo{}),
	ScheduledAt:          timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
	CreatedAt:            timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:            timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SamplePurchaseOrderLine = &PurchaseOrderLine{
	ID:                 SamplePurchaseOrderLineID,
	Object:             constants.ObjectTypePurchaseOrderLine,
	LineItemNumber:     1,
	ProductSKU:         SampleItemSKU,
	ProductDescription: &samplePurchaseOrderLineProductDescription,
	Item:               SampleItem,
	QuantityOrdered:    SampleQuantity,
	QuantityReceived:   SampleQuantity,
	UnitPrice:          SampleRate,
	UnitCost:           SampleRate,
	CreatedAt:          timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:          timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleQuantity = &Quantity{
	ID:           SampleQuantityID,
	Object:       constants.ObjectTypeQuantity,
	Value:        "1234.56",
	DisplayValue: "$1,234.56",
	Unit:         newSampleUnit("US Dollar", "$", constants.UnitTypeCurrency),
}

var SampleRate = &Rate{
	ID:              SampleRateID,
	Object:          constants.ObjectTypeRate,
	Value:           SampleRateValue,
	NumeratorUnit:   newSampleUnit("US Dollar", "USD", constants.UnitTypeCurrency),
	DenominatorUnit: newSampleUnit(SampleUnitName, SampleUnitAbbreviation, constants.UnitTypeMass),
	DisplayValue:    "$25.50 / " + SampleUnitAbbreviation,
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleRateShopOption = &RateShopOption{
	Object:        constants.ObjectTypeRateShopOption,
	Carrier:       SampleCarrier,
	ServiceLevel:  SampleServiceLevel,
	Rate:          12.34,
	EstimatedDays: &sampleRateShopEstimatedDays,
}

var SampleRateShopResult = &RateShopResult{
	Object:        constants.ObjectTypeRateShopResult,
	Options:       NewList([]RateShopOption{*SampleRateShopOption}, PageInfo{}),
	ExemptionType: new(constants.FreightExemptionTypeNone),
}

var SampleRealizedMarginFinding = &RealizedMarginFinding{
	ID:     SampleCustomerID + ":" + SampleItemID,
	Object: constants.ObjectTypeRealizedMarginFinding,
	Reason: constants.PricingFindingReasonBelowTargetMargin,
	QuantityInvoiced: &ComputedQuantity{
		Object:       constants.ObjectTypeComputedQuantity,
		Value:        "1200",
		DisplayValue: "1,200 " + SampleUnitAbbreviation,
	},
	Revenue: &ComputedQuantity{
		Object:       constants.ObjectTypeComputedQuantity,
		Value:        "16200.00",
		DisplayValue: "16,200.00",
	},
	Cost: &ComputedQuantity{
		Object:       constants.ObjectTypeComputedQuantity,
		Value:        "12800.00",
		DisplayValue: "12,800.00",
	},
	AverageUnitPrice: &ComputedRate{
		Object:       constants.ObjectTypeComputedRate,
		Value:        "13.5000",
		DisplayValue: "$13.50 / " + SampleUnitAbbreviation,
	},
	PeerMedianPrice: &ComputedRate{
		Object:       constants.ObjectTypeComputedRate,
		Value:        "18.0000",
		DisplayValue: "$18.00 / " + SampleUnitAbbreviation,
	},
	LineCount:               14,
	BelowPeerMedianFraction: &sampleRealizedBelowPeer,
	GrossMargin:             &sampleRealizedGrossMargin,
}

var SampleReceivableEntry = ReceivableEntry{
	Object:           constants.ObjectTypeReceivableEntry,
	Invoice:          SampleInvoice,
	Customer:         SampleCustomer,
	PONumber:         nil,
	InvoicedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	RemainingBalance: "1234.56",
	IsPaidInFull:     false,
}

var SampleReceivingOrder = &ReceivingOrder{
	ID:                   SampleReceivingOrderID,
	Object:               constants.ObjectTypeReceivingOrder,
	Number:               "RO-001",
	Note:                 &sampleReceivingOrderNote,
	PurchaseOrder:        SamplePurchaseOrder,
	Supplier:             SampleSupplier,
	Lines:                NewList([]ReceivingOrderLine{*SampleReceivingOrderLine}, PageInfo{}),
	LineCount:            2,
	CompletionPercentage: 50.0,
	CreatedAt:            timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:            timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleReceivingOrderLine = &ReceivingOrderLine{
	ID:        SampleReceivingOrderLineID,
	Object:    constants.ObjectTypeReceivingOrderLine,
	Quantity:  SampleQuantity,
	OrderLine: SampleSalesOrderLine,
	Item:      SampleItem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleRecord = &Record{
	ID:     SampleShipmentID,
	Object: constants.ObjectTypeRecord,
	Type:   constants.RecordTypeShipment,
	Number: &sampleRecordNumber,
	Status: new("fulfilled"),
	Metadata: map[string]string{
		"carrier":         "UPS",
		"tracking_number": "1Z999AA10123456784",
	},
}

var SampleRegistrationFlow = &RegistrationFlow{
	ID:                   SampleRegistrationFlowID,
	Object:               constants.ObjectTypeRegistrationFlow,
	Name:                 SampleRegistrationFlowName,
	CustomerGroupOptions: NewList([]RegistrationFlowOption{SampleRegistrationFlowOption}, PageInfo{}),
	PaymentTermOptions:   NewList([]RegistrationFlowOption{SampleRegistrationFlowOption}, PageInfo{}),
	ShippingTermOptions:  NewList([]RegistrationFlowOption{SampleRegistrationFlowOption}, PageInfo{}),
	CreatedAt:            timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:            timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleRegistrationFlowOption = RegistrationFlowOption{
	ID:     SampleRegistrationFlowOptionID,
	Object: constants.ObjectTypeRegistrationFlowOption,
	Name:   SampleRegistrationFlowOptionName,
}

var SampleRegistrationSession = &RegistrationSession{
	ID:                      SampleRegistrationSessionID,
	Object:                  constants.ObjectTypeRegistrationSession,
	PlanCode:                constants.PlanCodeStarter,
	Step:                    constants.RegistrationStepVerification,
	StripeCustomerID:        new(SampleStripeCustomerID),
	StripeCheckoutSessionID: new(SampleCheckoutSessionID),
	PaymentCompleted:        false,
	Account:                 SampleRegistrationSessionAccount,
	User:                    *SampleRegistrationSessionUser,
	CompletedAt:             nil,
	CreatedAt:               timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:               timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleRegistrationSessionAccount = &RegistrationSessionAccount{
	ID:             new(SampleAccountID),
	Object:         constants.ObjectTypeAccount,
	Name:           SampleAccountName,
	BillingAddress: *SampleRegistrationSessionAddress,
}

var SampleRegistrationSessionAddress = &RegistrationSessionAddress{
	ID:         new(SampleAddressID),
	Object:     constants.ObjectTypeAddress,
	Line1:      new(SampleAddressLine1),
	Line2:      new(SampleAddressLine2),
	City:       new(SampleAddressCity),
	State:      new(SampleAddressState),
	PostalCode: new(SampleAddressPostalCode),
	Country:    new(SampleAddressCountry),
}

var SampleRegistrationSessionUser = &RegistrationSessionUser{
	ID:              new(SampleUserID),
	Object:          constants.ObjectTypeUser,
	Email:           SampleUserEmail,
	Name:            new(SampleUserName),
	EmailVerifiedAt: timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
}

var SampleReleaseScheduleWeekPreview = &ReleaseScheduleWeekPreview{
	Object:        constants.ObjectTypeProductionScheduleWeekReleasePreview,
	WeekIndex:     0,
	WeekStartDate: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	LineCount:     1,
	BatchCount:    6,
	TotalQuantity: 360,
	IsReleasable:  true,
	Lines: NewList([]ReleasedScheduleLine{
		{
			Line:            NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
			Item:            NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
			SKU:             sampleScheduleSKU,
			Machine:         NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
			PlannedQuantity: 360,
			LotUnits:        60,
			BatchCount:      6,
			Batches: NewList([]ReleaseScheduleBatch{
				{Item: NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU), SKU: sampleScheduleSKU, Quantity: 60},
			}, PageInfo{}),
		},
	}, PageInfo{}),
}

var SampleReleaseScheduleWeekResult = &ReleaseScheduleWeekResult{
	Object:            constants.ObjectTypeProductionScheduleWeekRelease,
	ProductionRun:     SampleProductionRun,
	WeekIndex:         0,
	WeekStartDate:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	ReleasedLineCount: 1,
	BatchCount:        6,
	TotalQuantity:     360,
	Lines: NewList([]ReleasedScheduleLine{
		{
			Line:            NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
			Item:            NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
			SKU:             sampleScheduleSKU,
			Machine:         NewEntity(SampleMachineID, constants.ObjectTypeMachine, &sampleReleasedMachineName, nil),
			PlannedQuantity: 360,
			LotUnits:        60,
			BatchCount:      6,
			Batches: NewList([]ReleaseScheduleBatch{
				{
					Item:     NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
					SKU:      sampleScheduleSKU,
					Quantity: 60,
					Batch:    NewEntity(SampleBatchID, constants.ObjectTypeBatch, nil, nil),
				},
			}, PageInfo{}),
		},
	}, PageInfo{}),
}

var SampleRequestLog = &RequestLog{
	ID:               SampleRequestLogID,
	Object:           constants.ObjectTypeRequestLog,
	Method:           "GET",
	Host:             SampleRequestLogHost,
	Path:             SampleRequestLogPath,
	NormalizedRoute:  SampleRequestLogPath,
	QueryJSON:        json.RawMessage(SampleRequestLogQueryJSON),
	StatusCode:       200,
	LatencyUs:        12345,
	APIVersion:       new(SampleRequestLogAPIVersion),
	ClientIP:         new(SampleRequestLogClientIP),
	UserAgent:        new(SampleRequestLogUserAgent),
	Referrer:         new("https://www.openmrp.ai"),
	OccurredAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	Account:          SampleAccount,
	Actor:            SampleRequestLogActor,
	ResponseBodyJSON: json.RawMessage(SampleRequestLogResponseBody),
}

var SampleRequestLogActor = &Actor{
	ID:        SampleUserID,
	Object:    constants.ObjectTypeActor,
	Type:      constants.ActorTypeUser,
	Name:      new(SampleUserName),
	Handle:    new(SampleUserEmail),
	AvatarURL: new(SampleUserImageUrl),
	Role:      SampleRole,
}

var SampleRole = &Role{
	ID:          SampleRoleID,
	Name:        SampleRoleName,
	Object:      constants.ObjectTypeRole,
	TypeCode:    constants.RoleTypeAdmin,
	Owner:       SampleOwnerAccount,
	Permissions: &SampleRolePermissions,
	CreatedAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:   timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleRolePermission = &RolePermission{
	ID:             SampleRolePermissionID,
	Object:         constants.ObjectTypeRolePermission,
	PermissionCode: "customers",
	Create:         true,
	Read:           true,
	Update:         true,
	Delete:         false,
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleRolePermissions = []string{"customers:create", "customers:read", "customers:update", "customers:delete"}

var SampleSalesOrder = &SalesOrder{
	ID:                          SampleSalesOrderID,
	Object:                      constants.ObjectTypeSalesOrder,
	Number:                      SampleSalesOrderNumber,
	CustomerPurchaseOrderNumber: &sampleCustomerPurchaseOrderNumber,
	Note:                        &sampleNote,
	Status:                      constants.SalesOrderStatusCodeEstimate,
	Priority:                    SamplePriorityCode,
	PaymentStatus:               constants.SalesOrderPaymentStatusUnpaid,
	PaymentIntentIDs:            []string{},
	AcknowledgmentStatus:        constants.AcknowledgmentStatusNotSent,
	Customer:                    SampleCustomer,
	SalesRep:                    SampleActor,
	CreatedBy:                   SampleCreatedBy,
	BillToAddress:               SampleAddress,
	ShipToAddress:               SampleAddress,
	Freight:                     SampleFreight,
	PaymentTerm:                 SamplePaymentTerm,
	ShippingTerm:                SampleShippingTerm,
	OrderDiscount:               SampleOrderDiscount,
	Lines:                       NewList([]SalesOrderLine{*SampleSalesOrderLine}, PageInfo{}),
	LineCount:                   1,
	Totals:                      SampleSalesOrderTotals,
	Related:                     &SalesOrderRelated{Object: constants.ObjectTypeSalesOrderRelated},
	Contacts: &OrderContact{
		Object:          constants.ObjectTypeOrderContact,
		Invoice:         []string{"ap@acme.example.com"},
		Acknowledgement: []string{"purchasing@acme.example.com"},
	},
	PromisedAt: timeutil.TimestampToTimePtr(sampleExpiresAtTimestamp),
	CreatedAt:  timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:  timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSalesOrderLine = &SalesOrderLine{
	ID:                 SampleSalesOrderLineID,
	Object:             constants.ObjectTypeSalesOrderLine,
	LineItemNumber:     1,
	ProductSKU:         SampleItemSKU,
	ProductDescription: &sampleProductDescription,
	Item:               SampleItem,
	Product:            SampleProduct,
	QuantityOrdered:    SampleQuantity,
	UnitPrice:          SampleRate,
	UnitCost:           SampleRate,
	Totals:             SampleSalesOrderTotals,
	CreatedAt:          timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:          timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSalesOrderStatus = &SalesOrderStatus{
	ID:        SampleSalesOrderStatusID,
	Object:    constants.ObjectTypeSalesOrderStatus,
	Code:      SampleSalesOrderStatusCode,
	Name:      SampleSalesOrderStatusName,
	Owner:     SampleOwnerSystem,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSalesOrderStatusCode = constants.SalesOrderStatusCodeEstimate

var SampleSalesOrderStatusDetail = &SalesOrderStatusDetail{
	Code:   "estimate",
	Object: constants.ObjectTypeSalesOrderStatus,
	Name:   "Estimate",
}

var SampleSalesOrderTotals = &SalesOrderTotals{
	Object:   constants.ObjectTypeSalesOrderTotals,
	Ordered:  "1234.56",
	Picked:   SalesOrderStageTotal{Object: constants.ObjectTypeSalesOrderStageTotal, Amount: "617.280000000000000000000000000000", Completion: 0.5},
	Packed:   SalesOrderStageTotal{Object: constants.ObjectTypeSalesOrderStageTotal, Amount: "308.640000000000000000000000000000", Completion: 0.25},
	Invoiced: SalesOrderStageTotal{Object: constants.ObjectTypeSalesOrderStageTotal, Amount: "0.000000000000000000000000000000", Completion: 0},
}

var SampleSalesOrderType = &SalesOrderType{
	Code:   "standard",
	Object: constants.ObjectTypeSalesOrderType,
	Name:   "Standard",
}

var SampleSalesTarget = &SalesTarget{
	ID:        SampleSalesTargetID,
	Object:    constants.ObjectTypeSalesTarget,
	StartAt:   timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	EndAt:     timeutil.TimestampToTime(sampleExpiresAtTimestamp),
	SalesRep:  NewEntity(SampleAccountUserID, constants.ObjectTypeAccountUser, nil, nil),
	Amount:    SampleQuantity,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSandbox = &Sandbox{
	ID:     SampleSandboxID,
	Object: constants.ObjectTypeSandbox,
	Name:   SampleSandboxName,
	OwnerAccount: &Account{
		ID:        SampleAccountID,
		Object:    constants.ObjectTypeAccount,
		Name:      SampleAccountName,
		CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
		UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
	},
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleScanningConsumption = &ScanningConsumption{
	SKU:              SampleItemSKU,
	Object:           constants.ObjectTypeScanningConsumption,
	DemandMeasure:    "10.000000000000000000000000000000",
	DemandUnit:       "kg",
	InventoryMeasure: "100.000000000000000000000000000000",
	InventoryUnit:    "kg",
	Instructions:     nil,
}

var SampleScanningProductionStepInfo = &ScanningProductionStepInfo{
	ID:          SampleProductionStepID,
	Object:      constants.ObjectTypeScanningProductionStepInfo,
	Name:        "Mixing",
	IsMultiPart: false,
}

var SampleScanningStation = &ScanningStation{
	ID:                  SampleScanningStationID,
	Object:              constants.ObjectTypeScanningStation,
	Name:                SampleScanningStationName,
	Notes:               &sampleScanningStationNotes,
	Type:                constants.ScanningStationTypeInitBatch,
	LabelSizeCode:       new(constants.LabelSizeCodeTwoByFour),
	LabelTypeCode:       new(constants.LabelTypeCodeTraveler),
	OperatorRequirement: constants.OperatorRequirementNone,
	Department:          nil,
	ProductionSteps:     nil,
	CreatedAt:           timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:           timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleScheduleDeviationType = &ScheduleDeviationType{
	ID:        SampleScheduleDeviationTypeID,
	Object:    constants.ObjectTypeScheduleDeviationType,
	Code:      constants.ScheduleDeviationTypeQuantityChanged,
	Name:      "Quantity Changed",
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleScheduleOrderCoverage = &ScheduleOrderCoverage{
	Object:      constants.ObjectTypeScheduleOrderCoverage,
	SalesOrder:  NewEntity(SampleSalesOrderID, constants.ObjectTypeSalesOrder, nil, nil),
	Item:        NewEntity(SampleItemID, constants.ObjectTypeItem, nil, &sampleScheduleSKU),
	SKU:         sampleScheduleSKU,
	UnitsAtRisk: 200,
	DueWeek:     0,
	Reason:      constants.ScheduleAtRiskReasonPastDue,
	CoveringLines: NewList([]ScheduleOrderCoverageLine{{
		Object:                 constants.ObjectTypeScheduleOrderCoverageLine,
		ProductionScheduleLine: NewEntity(SampleProductionScheduleLineID, constants.ObjectTypeProductionScheduleLine, nil, nil),
		WeekIndex:              0,
		Machine:                NewEntity(SampleMachineID, constants.ObjectTypeMachine, nil, nil),
		AllocatedQuantity:      300,
	}}, PageInfo{}),
}

var SampleServiceLevel = &ServiceLevel{
	ID:                       SampleServiceLevelID,
	Object:                   constants.ObjectTypeServiceLevel,
	Name:                     SampleServiceLevelName,
	ServiceLevelToken:        "fedex_ground",
	CustomerPortalVisibility: constants.CustomerPortalVisibilityVisible,
	IsDefault:                true,
	DefaultTransitDays:       &sampleServiceLevelTransitDays,
	Owner:                    SampleOwnerAccount,
	CreatedAt:                timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:                timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSettlement = &Settlement{
	ID:              SampleSettlementID,
	Object:          constants.ObjectTypeSettlement,
	Number:          "1",
	Note:            &sampleSettlementNote,
	ResponsibleUser: SampleAccountUser,
	Allocations:     NewList([]TransactionAllocation{*SampleTransactionAllocation2}, PageInfo{}),
	CreatedAt:       timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:       timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSettlementSummary = &SettlementSummary{
	ID:               SampleSettlementSummaryID,
	Object:           constants.ObjectTypeSettlementSummary,
	Number:           "1",
	AllocationCount:  2,
	TotalPayments:    new("500.000000000000000000000000000000"),
	TotalRebates:     new("0.000000000000000000000000000000"),
	TotalAdjustments: new("0.000000000000000000000000000000"),
	TotalCredits:     new("250.000000000000000000000000000000"),
	InvoiceNumbers:   []string{"INV-001", "INV-002"},
	CustomerNames:    []string{"Acme Corp"},
	CreatedAt:        timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:        timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSetupBillingResponse = &SetupBillingResponse{
	Object:           constants.ObjectTypeSetupBillingResponse,
	StripeCustomerID: SampleStripeCustomerID,
	ClientSecret:     "seti_1234_secret_5678",
	PublishableKey:   "pk_test_example",
}

var SampleShipment = &Shipment{
	ID:                   SampleShipmentID,
	Object:               constants.ObjectTypeShipment,
	Number:               SampleShipmentNumber,
	Note:                 &sampleShipmentNote,
	BillOfLading:         &sampleBillOfLading,
	MasterTrackingNumber: &sampleMasterTrackingNumber,
	Status:               constants.ShipmentStatusShipped,
	ShippedAt:            timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	Priority:             SamplePriorityCode,
	CaseCount:            1,
	Customer:             SampleCustomer,
	Freight:              SampleFreight,
	ShippingAddress:      SampleAddress,
	ShippedBy:            SampleCreatedBy,
	Lines:                NewList([]ShipmentLine{*SampleShipmentLine}, PageInfo{}),
	ShippingCases:        NewList([]ShippingCaseDetail{sampleShippingCaseDetail}, PageInfo{}),
	Related:              &ShipmentRelated{Object: constants.ObjectTypeShipmentRelated},
	CreatedAt:            timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:            timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleShipmentLine = &ShipmentLine{
	ID:             SampleShipmentLineID,
	Object:         constants.ObjectTypeShipmentLine,
	SalesOrderLine: SampleSalesOrderLine,
	Item:           SampleItem,
	Quantity:       SampleQuantity,
	CreatedAt:      timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:      timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleShippingCase = &ShippingCase{
	ID:             SampleShippingCaseID,
	Object:         constants.ObjectTypeShippingCase,
	Number:         "SC-0001",
	SSCC:           new("003456789000000018"),
	TrackingNumber: new("1Z999AA10123456784"),
	ShippedAt:      timeutil.TimestampToTimePtr(sampleUpdatedAtTimestamp),
	FreightAmount: &Quantity{
		ID:           SampleQuantityID,
		Object:       constants.ObjectTypeQuantity,
		Value:        "12.500000000000000000000000000000",
		DisplayValue: "$12.50",
		Unit:         newSampleUnit("US Dollar", "$", constants.UnitTypeCurrency),
	},
	FreightWeight: &Quantity{
		ID:           SampleQuantityID,
		Object:       constants.ObjectTypeQuantity,
		Value:        "5.000000000000000000000000000000",
		DisplayValue: "5 lb",
		Unit:         newSampleUnit("Pound", "lb", constants.UnitTypeMass),
	},
	Shipment:  nil,
	Carrier:   nil,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleShippingCaseLabelURL = &ShippingCaseLabelURL{
	Object: constants.ObjectTypeShippingCaseLabelURL,
	URL:    nil,
}

var SampleShippingTerm = &ShippingTerm{
	ID:                        SampleShippingTermID,
	Object:                    constants.ObjectTypeShippingTerm,
	Name:                      SampleShippingTermName,
	Type:                      constants.ShippingTermTypeCarrierRateFreight,
	Owner:                     SampleOwnerSystem,
	FlatRate:                  nil,
	MinimumOrderValue:         nil,
	FreeShippingServiceLevels: NewList([]ServiceLevel{}, PageInfo{}),
	CreatedAt:                 timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:                 timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSpendingCapResponse = &SpendingCapResponse{
	Object:   constants.ObjectTypeSpendingCapResponse,
	CapCents: &sampleCapCents,
}

var SampleStripePublishableKey = &StripePublishableKey{
	Object:         constants.ObjectTypeStripePublishableKey,
	PublishableKey: "pk_test_example123",
}

var SampleStripeStatus = &StripeStatus{
	Object: constants.ObjectTypeStripeStatus,
	Status: constants.StripeConnectionStatusConnected,
}

var SampleSubscriptionInfo = &SubscriptionInfo{
	Object:           constants.ObjectTypeSubscriptionInfo,
	ServicingStatus:  "active",
	CollectionStatus: "current",
}

var SampleSupplier = &Supplier{
	ID:     SampleSupplierID,
	Object: constants.ObjectTypeSupplier,
	Name:   SampleSupplierName,
	Number: SampleSupplierNumber,
}

var SampleSupplierDetail = &SupplierDetail{
	ID:            SampleSupplierID,
	Object:        constants.ObjectTypeSupplier,
	Name:          SampleSupplierName,
	Number:        SampleSupplierNumber,
	Note:          nil,
	BillToAddress: SampleAddress,
	ShipToAddress: SampleAddress,
	MaterialCount: 5,
	CreatedAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:     timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSupplierMaterial = &SupplierMaterial{
	ID:                  SampleSupplierMaterialID,
	Object:              constants.ObjectTypeSupplierMaterial,
	Material:            SampleMaterial,
	SupplierPartNumber:  sampleSupplierPartNumber,
	SupplierDescription: &sampleSupplierDescription,
	Status:              constants.SupplierMaterialStatusActive,
	CreatedAt:           timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:           timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSupplierSummary = &SupplierSummary{
	ID:            SampleSupplierID,
	Object:        constants.ObjectTypeSupplierSummary,
	Name:          SampleSupplierName,
	Number:        SampleSupplierNumber,
	MaterialCount: 5,
	CreatedAt:     timeutil.TimestampToTime(sampleCreatedAtTimestamp),
}

var SampleSupportAvailability = &SupportAvailability{
	Object:    constants.ObjectTypeSupportAvailability,
	Available: true,
}

var SampleSupportRoute = &SupportRoute{
	ID:                SampleSupportRouteID,
	Object:            constants.ObjectTypeSupportRoute,
	RelationAccount:   NewEntity(SampleAccountID, constants.ObjectTypeAccount, new(SampleAccountName), nil),
	GroupConversation: NewEntity(SampleConversationID, constants.ObjectTypeConversation, nil, nil),
	CreatedAt:         timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt:         timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}

var SampleSwitchPlanResponse = &SwitchPlanResponse{
	Object:   constants.ObjectTypeSwitchPlanResponse,
	Success:  true,
	IntentID: &sampleSwitchPlanIntentID,
}

var SampleSysProperty = &SysProperty{
	ID:     SampleSysPropertyID,
	Object: constants.ObjectTypeSysProperty,
	Type: &SysPropertyType{
		ID:     SampleSysPropertyTypeID,
		Object: constants.ObjectTypeSysPropertyType,
		Name:   SampleSysPropertyTypeName,
		Code:   SampleSysPropertyTypeCode,
	},
	Value:     SampleSysPropertyValueInt,
	CreatedAt: timeutil.TimestampToTime(sampleCreatedAtTimestamp),
	UpdatedAt: timeutil.TimestampToTime(sampleUpdatedAtTimestamp),
}