diff --git a/db/migrations/000001_fortune.up.sql b/db/migrations/000001_fortune.up.sql
index e791639..6f2043c 100644
--- a/db/migrations/000001_fortune.up.sql
+++ b/db/migrations/000001_fortune.up.sql
@@ -56,7 +56,7 @@ ON virtual_game_provider_reports (provider_id, report_date, report_type);
 
 CREATE TABLE IF NOT EXISTS virtual_games (
     id BIGSERIAL PRIMARY KEY,
-    game_id VARCHAR(150) NOT NULL,
+    game_id VARCHAR(150) UNIQUE NOT NULL,
     provider_id VARCHAR(100) NOT NULL REFERENCES virtual_game_providers(provider_id) ON DELETE CASCADE,
     name VARCHAR(255) NOT NULL,
     category VARCHAR(100),
diff --git a/db/migrations/00008_enet_pulse.up.sql b/db/migrations/00008_enet_pulse.up.sql
index faa33a7..416bddf 100644
--- a/db/migrations/00008_enet_pulse.up.sql
+++ b/db/migrations/00008_enet_pulse.up.sql
@@ -67,9 +67,9 @@ CREATE TABLE IF NOT EXISTS enetpulse_fixtures (
     sport_fk VARCHAR(50) NOT NULL REFERENCES enetpulse_sports(sport_id) ON DELETE CASCADE,
     tournament_fk VARCHAR(50),  -- raw tournamentFK (optional)
     tournament_template_fk VARCHAR(50) REFERENCES enetpulse_tournament_templates(template_id) ON DELETE CASCADE,
-    tournament_stage_fk VARCHAR(50) REFERENCES enetpulse_tournament_stages(stage_id) ON DELETE CASCADE,
+    -- tournament_stage_fk VARCHAR(50) REFERENCES enetpulse_tournament_stages(stage_id) ON DELETE CASCADE,
 
-    tournament_stage_name VARCHAR(255),
+    -- tournament_stage_name VARCHAR(255),
     tournament_name VARCHAR(255),
     tournament_template_name VARCHAR(255),
     sport_name VARCHAR(255),
@@ -94,9 +94,9 @@ CREATE TABLE IF NOT EXISTS enetpulse_results (
     sport_fk VARCHAR(50) NOT NULL REFERENCES enetpulse_sports(sport_id) ON DELETE CASCADE,
     tournament_fk VARCHAR(50),
     tournament_template_fk VARCHAR(50) REFERENCES enetpulse_tournament_templates(template_id) ON DELETE CASCADE,
-    tournament_stage_fk VARCHAR(50) REFERENCES enetpulse_tournament_stages(stage_id) ON DELETE CASCADE,
+    -- tournament_stage_fk VARCHAR(50) REFERENCES enetpulse_tournament_stages(stage_id) ON DELETE CASCADE,
 
-    tournament_stage_name VARCHAR(255),
+    -- tournament_stage_name VARCHAR(255),
     tournament_name VARCHAR(255),
     tournament_template_name VARCHAR(255),
     sport_name VARCHAR(255),
diff --git a/db/query/enet_pulse.sql b/db/query/enet_pulse.sql
index 1f9c195..96cf090 100644
--- a/db/query/enet_pulse.sql
+++ b/db/query/enet_pulse.sql
@@ -154,8 +154,6 @@ INSERT INTO enetpulse_fixtures (
     sport_fk,
     tournament_fk,
     tournament_template_fk,
-    tournament_stage_fk,
-    tournament_stage_name,
     tournament_name,
     tournament_template_name,
     sport_name,
@@ -169,7 +167,7 @@ INSERT INTO enetpulse_fixtures (
     created_at,
     updated_at
 ) VALUES (
-    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,CURRENT_TIMESTAMP,CURRENT_TIMESTAMP
+    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,CURRENT_TIMESTAMP,CURRENT_TIMESTAMP
 )
 ON CONFLICT (fixture_id) DO UPDATE
 SET
@@ -177,8 +175,6 @@ SET
     sport_fk = EXCLUDED.sport_fk,
     tournament_fk = EXCLUDED.tournament_fk,
     tournament_template_fk = EXCLUDED.tournament_template_fk,
-    tournament_stage_fk = EXCLUDED.tournament_stage_fk,
-    tournament_stage_name = EXCLUDED.tournament_stage_name,
     tournament_name = EXCLUDED.tournament_name,
     tournament_template_name = EXCLUDED.tournament_template_name,
     sport_name = EXCLUDED.sport_name,
@@ -192,6 +188,7 @@ SET
     updated_at = CURRENT_TIMESTAMP
 RETURNING *;
 
+
 -- name: GetAllEnetpulseFixtures :many
 SELECT *
 FROM enetpulse_fixtures
@@ -204,8 +201,6 @@ INSERT INTO enetpulse_results (
     sport_fk,
     tournament_fk,
     tournament_template_fk,
-    tournament_stage_fk,
-    tournament_stage_name,
     tournament_name,
     tournament_template_name,
     sport_name,
@@ -228,14 +223,14 @@ INSERT INTO enetpulse_results (
     first_half_ended,
     second_half_started,
     second_half_ended,
-    game_ended
+    game_ended,
+    created_at,
+    updated_at
 ) VALUES (
-    $1, $2, $3, $4, $5, $6,
-    $7, $8, $9, $10, $11,
-    $12, $13, $14, $15, $16,
-    $17, $18, $19, $20, $21,
-    $22, $23, $24, $25, $26,
-    $27, $28, $29, $30
+    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,
+    $11,$12,$13,$14,$15,$16,$17,$18,
+    $19,$20,$21,$22,$23,$24,$25,$26,
+    $27,$28,CURRENT_TIMESTAMP,CURRENT_TIMESTAMP
 )
 ON CONFLICT (result_id) DO UPDATE
 SET
@@ -243,8 +238,6 @@ SET
     sport_fk = EXCLUDED.sport_fk,
     tournament_fk = EXCLUDED.tournament_fk,
     tournament_template_fk = EXCLUDED.tournament_template_fk,
-    tournament_stage_fk = EXCLUDED.tournament_stage_fk,
-    tournament_stage_name = EXCLUDED.tournament_stage_name,
     tournament_name = EXCLUDED.tournament_name,
     tournament_template_name = EXCLUDED.tournament_template_name,
     sport_name = EXCLUDED.sport_name,
@@ -276,6 +269,80 @@ SELECT *
 FROM enetpulse_results
 ORDER BY created_at DESC;
 
+-- name: CreateEnetpulseResultParticipant :one
+INSERT INTO enetpulse_result_participants (
+    participant_map_id,
+    result_fk,
+    participant_fk,
+    number,
+    name,
+    gender,
+    type,
+    country_fk,
+    country_name,
+    ordinary_time,
+    running_score,
+    halftime,
+    final_result,
+    last_updated_at,
+    created_at
+) VALUES (
+    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,CURRENT_TIMESTAMP
+)
+ON CONFLICT (participant_map_id) DO UPDATE
+SET
+    result_fk = EXCLUDED.result_fk,
+    participant_fk = EXCLUDED.participant_fk,
+    number = EXCLUDED.number,
+    name = EXCLUDED.name,
+    gender = EXCLUDED.gender,
+    type = EXCLUDED.type,
+    country_fk = EXCLUDED.country_fk,
+    country_name = EXCLUDED.country_name,
+    ordinary_time = EXCLUDED.ordinary_time,
+    running_score = EXCLUDED.running_score,
+    halftime = EXCLUDED.halftime,
+    final_result = EXCLUDED.final_result,
+    last_updated_at = EXCLUDED.last_updated_at
+RETURNING *;
+
+-- name: GetEnetpulseResultParticipantsByResultFK :many
+SELECT *
+FROM enetpulse_result_participants
+WHERE result_fk = $1
+ORDER BY created_at DESC;
+
+-- name: CreateEnetpulseResultReferee :one
+INSERT INTO enetpulse_result_referees (
+    result_fk,
+    referee_fk,
+    assistant1_referee_fk,
+    assistant2_referee_fk,
+    fourth_referee_fk,
+    var1_referee_fk,
+    var2_referee_fk,
+    last_updated_at,
+    created_at
+) VALUES (
+    $1,$2,$3,$4,$5,$6,$7,$8,CURRENT_TIMESTAMP
+)
+ON CONFLICT (result_fk) DO UPDATE
+SET
+    referee_fk = EXCLUDED.referee_fk,
+    assistant1_referee_fk = EXCLUDED.assistant1_referee_fk,
+    assistant2_referee_fk = EXCLUDED.assistant2_referee_fk,
+    fourth_referee_fk = EXCLUDED.fourth_referee_fk,
+    var1_referee_fk = EXCLUDED.var1_referee_fk,
+    var2_referee_fk = EXCLUDED.var2_referee_fk,
+    last_updated_at = EXCLUDED.last_updated_at
+RETURNING *;
+
+-- name: GetEnetpulseResultRefereesByResultFK :many
+SELECT *
+FROM enetpulse_result_referees
+WHERE result_fk = $1
+ORDER BY created_at DESC;
+
 -- name: CreateEnetpulseOutcomeType :one
 INSERT INTO enetpulse_outcome_types (
     outcome_type_id,
@@ -389,7 +456,6 @@ SELECT
     f.sport_fk,
     f.tournament_fk,
     f.tournament_template_fk,
-    f.tournament_stage_fk,
     f.start_date,
     f.status_type,
     f.status_desc_fk,
diff --git a/docker-compose.yml b/docker-compose.yml
index 6e5e7de..933a16d 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -25,7 +25,7 @@ services:
     image: mongo:7.0.11
     restart: always
     ports:
-      - "27022:27017"
+      - "27025:27017"
     environment:
       MONGO_INITDB_ROOT_USERNAME: root
       MONGO_INITDB_ROOT_PASSWORD: secret
diff --git a/gen/db/enet_pulse.sql.go b/gen/db/enet_pulse.sql.go
index 6a8c063..aafaad4 100644
--- a/gen/db/enet_pulse.sql.go
+++ b/gen/db/enet_pulse.sql.go
@@ -18,8 +18,6 @@ INSERT INTO enetpulse_fixtures (
     sport_fk,
     tournament_fk,
     tournament_template_fk,
-    tournament_stage_fk,
-    tournament_stage_name,
     tournament_name,
     tournament_template_name,
     sport_name,
@@ -33,7 +31,7 @@ INSERT INTO enetpulse_fixtures (
     created_at,
     updated_at
 ) VALUES (
-    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,CURRENT_TIMESTAMP,CURRENT_TIMESTAMP
+    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,CURRENT_TIMESTAMP,CURRENT_TIMESTAMP
 )
 ON CONFLICT (fixture_id) DO UPDATE
 SET
@@ -41,8 +39,6 @@ SET
     sport_fk = EXCLUDED.sport_fk,
     tournament_fk = EXCLUDED.tournament_fk,
     tournament_template_fk = EXCLUDED.tournament_template_fk,
-    tournament_stage_fk = EXCLUDED.tournament_stage_fk,
-    tournament_stage_name = EXCLUDED.tournament_stage_name,
     tournament_name = EXCLUDED.tournament_name,
     tournament_template_name = EXCLUDED.tournament_template_name,
     sport_name = EXCLUDED.sport_name,
@@ -54,7 +50,7 @@ SET
     updates_count = EXCLUDED.updates_count,
     last_updated_at = EXCLUDED.last_updated_at,
     updated_at = CURRENT_TIMESTAMP
-RETURNING id, fixture_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_stage_fk, tournament_stage_name, tournament_name, tournament_template_name, sport_name, gender, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, created_at, updated_at
+RETURNING id, fixture_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_name, tournament_template_name, sport_name, gender, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, created_at, updated_at
 `
 
 type CreateEnetpulseFixtureParams struct {
@@ -63,8 +59,6 @@ type CreateEnetpulseFixtureParams struct {
 	SportFk                string             `json:"sport_fk"`
 	TournamentFk           pgtype.Text        `json:"tournament_fk"`
 	TournamentTemplateFk   pgtype.Text        `json:"tournament_template_fk"`
-	TournamentStageFk      pgtype.Text        `json:"tournament_stage_fk"`
-	TournamentStageName    pgtype.Text        `json:"tournament_stage_name"`
 	TournamentName         pgtype.Text        `json:"tournament_name"`
 	TournamentTemplateName pgtype.Text        `json:"tournament_template_name"`
 	SportName              pgtype.Text        `json:"sport_name"`
@@ -84,8 +78,6 @@ func (q *Queries) CreateEnetpulseFixture(ctx context.Context, arg CreateEnetpuls
 		arg.SportFk,
 		arg.TournamentFk,
 		arg.TournamentTemplateFk,
-		arg.TournamentStageFk,
-		arg.TournamentStageName,
 		arg.TournamentName,
 		arg.TournamentTemplateName,
 		arg.SportName,
@@ -105,8 +97,6 @@ func (q *Queries) CreateEnetpulseFixture(ctx context.Context, arg CreateEnetpuls
 		&i.SportFk,
 		&i.TournamentFk,
 		&i.TournamentTemplateFk,
-		&i.TournamentStageFk,
-		&i.TournamentStageName,
 		&i.TournamentName,
 		&i.TournamentTemplateName,
 		&i.SportName,
@@ -351,8 +341,6 @@ INSERT INTO enetpulse_results (
     sport_fk,
     tournament_fk,
     tournament_template_fk,
-    tournament_stage_fk,
-    tournament_stage_name,
     tournament_name,
     tournament_template_name,
     sport_name,
@@ -375,14 +363,14 @@ INSERT INTO enetpulse_results (
     first_half_ended,
     second_half_started,
     second_half_ended,
-    game_ended
+    game_ended,
+    created_at,
+    updated_at
 ) VALUES (
-    $1, $2, $3, $4, $5, $6,
-    $7, $8, $9, $10, $11,
-    $12, $13, $14, $15, $16,
-    $17, $18, $19, $20, $21,
-    $22, $23, $24, $25, $26,
-    $27, $28, $29, $30
+    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,
+    $11,$12,$13,$14,$15,$16,$17,$18,
+    $19,$20,$21,$22,$23,$24,$25,$26,
+    $27,$28,CURRENT_TIMESTAMP,CURRENT_TIMESTAMP
 )
 ON CONFLICT (result_id) DO UPDATE
 SET
@@ -390,8 +378,6 @@ SET
     sport_fk = EXCLUDED.sport_fk,
     tournament_fk = EXCLUDED.tournament_fk,
     tournament_template_fk = EXCLUDED.tournament_template_fk,
-    tournament_stage_fk = EXCLUDED.tournament_stage_fk,
-    tournament_stage_name = EXCLUDED.tournament_stage_name,
     tournament_name = EXCLUDED.tournament_name,
     tournament_template_name = EXCLUDED.tournament_template_name,
     sport_name = EXCLUDED.sport_name,
@@ -416,7 +402,7 @@ SET
     second_half_ended = EXCLUDED.second_half_ended,
     game_ended = EXCLUDED.game_ended,
     updated_at = CURRENT_TIMESTAMP
-RETURNING id, result_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_stage_fk, tournament_stage_name, tournament_name, tournament_template_name, sport_name, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, round, live, venue_name, livestats_plus, livestats_type, commentary, lineup_confirmed, verified, spectators, game_started, first_half_ended, second_half_started, second_half_ended, game_ended, created_at, updated_at
+RETURNING id, result_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_name, tournament_template_name, sport_name, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, round, live, venue_name, livestats_plus, livestats_type, commentary, lineup_confirmed, verified, spectators, game_started, first_half_ended, second_half_started, second_half_ended, game_ended, created_at, updated_at
 `
 
 type CreateEnetpulseResultParams struct {
@@ -425,8 +411,6 @@ type CreateEnetpulseResultParams struct {
 	SportFk                string             `json:"sport_fk"`
 	TournamentFk           pgtype.Text        `json:"tournament_fk"`
 	TournamentTemplateFk   pgtype.Text        `json:"tournament_template_fk"`
-	TournamentStageFk      pgtype.Text        `json:"tournament_stage_fk"`
-	TournamentStageName    pgtype.Text        `json:"tournament_stage_name"`
 	TournamentName         pgtype.Text        `json:"tournament_name"`
 	TournamentTemplateName pgtype.Text        `json:"tournament_template_name"`
 	SportName              pgtype.Text        `json:"sport_name"`
@@ -459,8 +443,6 @@ func (q *Queries) CreateEnetpulseResult(ctx context.Context, arg CreateEnetpulse
 		arg.SportFk,
 		arg.TournamentFk,
 		arg.TournamentTemplateFk,
-		arg.TournamentStageFk,
-		arg.TournamentStageName,
 		arg.TournamentName,
 		arg.TournamentTemplateName,
 		arg.SportName,
@@ -493,8 +475,6 @@ func (q *Queries) CreateEnetpulseResult(ctx context.Context, arg CreateEnetpulse
 		&i.SportFk,
 		&i.TournamentFk,
 		&i.TournamentTemplateFk,
-		&i.TournamentStageFk,
-		&i.TournamentStageName,
 		&i.TournamentName,
 		&i.TournamentTemplateName,
 		&i.SportName,
@@ -524,6 +504,164 @@ func (q *Queries) CreateEnetpulseResult(ctx context.Context, arg CreateEnetpulse
 	return i, err
 }
 
+const CreateEnetpulseResultParticipant = `-- name: CreateEnetpulseResultParticipant :one
+INSERT INTO enetpulse_result_participants (
+    participant_map_id,
+    result_fk,
+    participant_fk,
+    number,
+    name,
+    gender,
+    type,
+    country_fk,
+    country_name,
+    ordinary_time,
+    running_score,
+    halftime,
+    final_result,
+    last_updated_at,
+    created_at
+) VALUES (
+    $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,CURRENT_TIMESTAMP
+)
+ON CONFLICT (participant_map_id) DO UPDATE
+SET
+    result_fk = EXCLUDED.result_fk,
+    participant_fk = EXCLUDED.participant_fk,
+    number = EXCLUDED.number,
+    name = EXCLUDED.name,
+    gender = EXCLUDED.gender,
+    type = EXCLUDED.type,
+    country_fk = EXCLUDED.country_fk,
+    country_name = EXCLUDED.country_name,
+    ordinary_time = EXCLUDED.ordinary_time,
+    running_score = EXCLUDED.running_score,
+    halftime = EXCLUDED.halftime,
+    final_result = EXCLUDED.final_result,
+    last_updated_at = EXCLUDED.last_updated_at
+RETURNING id, participant_map_id, result_fk, participant_fk, number, name, gender, type, country_fk, country_name, ordinary_time, running_score, halftime, final_result, last_updated_at, created_at
+`
+
+type CreateEnetpulseResultParticipantParams struct {
+	ParticipantMapID string             `json:"participant_map_id"`
+	ResultFk         string             `json:"result_fk"`
+	ParticipantFk    string             `json:"participant_fk"`
+	Number           pgtype.Int4        `json:"number"`
+	Name             pgtype.Text        `json:"name"`
+	Gender           pgtype.Text        `json:"gender"`
+	Type             pgtype.Text        `json:"type"`
+	CountryFk        pgtype.Text        `json:"country_fk"`
+	CountryName      pgtype.Text        `json:"country_name"`
+	OrdinaryTime     pgtype.Text        `json:"ordinary_time"`
+	RunningScore     pgtype.Text        `json:"running_score"`
+	Halftime         pgtype.Text        `json:"halftime"`
+	FinalResult      pgtype.Text        `json:"final_result"`
+	LastUpdatedAt    pgtype.Timestamptz `json:"last_updated_at"`
+}
+
+func (q *Queries) CreateEnetpulseResultParticipant(ctx context.Context, arg CreateEnetpulseResultParticipantParams) (EnetpulseResultParticipant, error) {
+	row := q.db.QueryRow(ctx, CreateEnetpulseResultParticipant,
+		arg.ParticipantMapID,
+		arg.ResultFk,
+		arg.ParticipantFk,
+		arg.Number,
+		arg.Name,
+		arg.Gender,
+		arg.Type,
+		arg.CountryFk,
+		arg.CountryName,
+		arg.OrdinaryTime,
+		arg.RunningScore,
+		arg.Halftime,
+		arg.FinalResult,
+		arg.LastUpdatedAt,
+	)
+	var i EnetpulseResultParticipant
+	err := row.Scan(
+		&i.ID,
+		&i.ParticipantMapID,
+		&i.ResultFk,
+		&i.ParticipantFk,
+		&i.Number,
+		&i.Name,
+		&i.Gender,
+		&i.Type,
+		&i.CountryFk,
+		&i.CountryName,
+		&i.OrdinaryTime,
+		&i.RunningScore,
+		&i.Halftime,
+		&i.FinalResult,
+		&i.LastUpdatedAt,
+		&i.CreatedAt,
+	)
+	return i, err
+}
+
+const CreateEnetpulseResultReferee = `-- name: CreateEnetpulseResultReferee :one
+INSERT INTO enetpulse_result_referees (
+    result_fk,
+    referee_fk,
+    assistant1_referee_fk,
+    assistant2_referee_fk,
+    fourth_referee_fk,
+    var1_referee_fk,
+    var2_referee_fk,
+    last_updated_at,
+    created_at
+) VALUES (
+    $1,$2,$3,$4,$5,$6,$7,$8,CURRENT_TIMESTAMP
+)
+ON CONFLICT (result_fk) DO UPDATE
+SET
+    referee_fk = EXCLUDED.referee_fk,
+    assistant1_referee_fk = EXCLUDED.assistant1_referee_fk,
+    assistant2_referee_fk = EXCLUDED.assistant2_referee_fk,
+    fourth_referee_fk = EXCLUDED.fourth_referee_fk,
+    var1_referee_fk = EXCLUDED.var1_referee_fk,
+    var2_referee_fk = EXCLUDED.var2_referee_fk,
+    last_updated_at = EXCLUDED.last_updated_at
+RETURNING id, result_fk, referee_fk, assistant1_referee_fk, assistant2_referee_fk, fourth_referee_fk, var1_referee_fk, var2_referee_fk, last_updated_at, created_at
+`
+
+type CreateEnetpulseResultRefereeParams struct {
+	ResultFk            string             `json:"result_fk"`
+	RefereeFk           pgtype.Text        `json:"referee_fk"`
+	Assistant1RefereeFk pgtype.Text        `json:"assistant1_referee_fk"`
+	Assistant2RefereeFk pgtype.Text        `json:"assistant2_referee_fk"`
+	FourthRefereeFk     pgtype.Text        `json:"fourth_referee_fk"`
+	Var1RefereeFk       pgtype.Text        `json:"var1_referee_fk"`
+	Var2RefereeFk       pgtype.Text        `json:"var2_referee_fk"`
+	LastUpdatedAt       pgtype.Timestamptz `json:"last_updated_at"`
+}
+
+func (q *Queries) CreateEnetpulseResultReferee(ctx context.Context, arg CreateEnetpulseResultRefereeParams) (EnetpulseResultReferee, error) {
+	row := q.db.QueryRow(ctx, CreateEnetpulseResultReferee,
+		arg.ResultFk,
+		arg.RefereeFk,
+		arg.Assistant1RefereeFk,
+		arg.Assistant2RefereeFk,
+		arg.FourthRefereeFk,
+		arg.Var1RefereeFk,
+		arg.Var2RefereeFk,
+		arg.LastUpdatedAt,
+	)
+	var i EnetpulseResultReferee
+	err := row.Scan(
+		&i.ID,
+		&i.ResultFk,
+		&i.RefereeFk,
+		&i.Assistant1RefereeFk,
+		&i.Assistant2RefereeFk,
+		&i.FourthRefereeFk,
+		&i.Var1RefereeFk,
+		&i.Var2RefereeFk,
+		&i.LastUpdatedAt,
+		&i.CreatedAt,
+	)
+	return i, err
+}
+
 const CreateEnetpulseSport = `-- name: CreateEnetpulseSport :one
 INSERT INTO enetpulse_sports (
     sport_id,
@@ -781,7 +919,7 @@ func (q *Queries) CreateEnetpulseTournamentTemplate(ctx context.Context, arg Cre
 }
 
 const GetAllEnetpulseFixtures = `-- name: GetAllEnetpulseFixtures :many
-SELECT id, fixture_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_stage_fk, tournament_stage_name, tournament_name, tournament_template_name, sport_name, gender, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, created_at, updated_at
+SELECT id, fixture_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_name, tournament_template_name, sport_name, gender, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, created_at, updated_at
 FROM enetpulse_fixtures
 ORDER BY created_at DESC
 `
@@ -802,8 +940,6 @@ func (q *Queries) GetAllEnetpulseFixtures(ctx context.Context) ([]EnetpulseFixtu
 			&i.SportFk,
 			&i.TournamentFk,
 			&i.TournamentTemplateFk,
-			&i.TournamentStageFk,
-			&i.TournamentStageName,
 			&i.TournamentName,
 			&i.TournamentTemplateName,
 			&i.SportName,
@@ -946,7 +1082,7 @@ func (q *Queries) GetAllEnetpulsePreoddsBettingOffers(ctx context.Context) ([]En
 }
 
 const GetAllEnetpulseResults = `-- name: GetAllEnetpulseResults :many
-SELECT id, result_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_stage_fk, tournament_stage_name, tournament_name, tournament_template_name, sport_name, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, round, live, venue_name, livestats_plus, livestats_type, commentary, lineup_confirmed, verified, spectators, game_started, first_half_ended, second_half_started, second_half_ended, game_ended, created_at, updated_at
+SELECT id, result_id, name, sport_fk, tournament_fk, tournament_template_fk, tournament_name, tournament_template_name, sport_name, start_date, status_type, status_desc_fk, round_type_fk, updates_count, last_updated_at, round, live, venue_name, livestats_plus, livestats_type, commentary, lineup_confirmed, verified, spectators, game_started, first_half_ended, second_half_started, second_half_ended, game_ended, created_at, updated_at
 FROM enetpulse_results
 ORDER BY created_at DESC
 `
@@ -967,8 +1103,6 @@ func (q *Queries) GetAllEnetpulseResults(ctx context.Context) ([]EnetpulseResult
 			&i.SportFk,
 			&i.TournamentFk,
 			&i.TournamentTemplateFk,
-			&i.TournamentStageFk,
-			&i.TournamentStageName,
 			&i.TournamentName,
 			&i.TournamentTemplateName,
 			&i.SportName,
@@ -1172,6 +1306,88 @@ func (q *Queries) GetAllEnetpulseTournaments(ctx context.Context) ([]EnetpulseTo
 	return items, nil
 }
 
+const GetEnetpulseResultParticipantsByResultFK = `-- name: GetEnetpulseResultParticipantsByResultFK :many
+SELECT id, participant_map_id, result_fk, participant_fk, number, name, gender, type, country_fk, country_name, ordinary_time, running_score, halftime, final_result, last_updated_at, created_at
+FROM enetpulse_result_participants
+WHERE result_fk = $1
+ORDER BY created_at DESC
+`
+
+func (q *Queries) GetEnetpulseResultParticipantsByResultFK(ctx context.Context, resultFk string) ([]EnetpulseResultParticipant, error) {
+	rows, err := q.db.Query(ctx, GetEnetpulseResultParticipantsByResultFK, resultFk)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []EnetpulseResultParticipant
+	for rows.Next() {
+		var i EnetpulseResultParticipant
+		if err := rows.Scan(
+			&i.ID,
+			&i.ParticipantMapID,
+			&i.ResultFk,
+			&i.ParticipantFk,
+			&i.Number,
+			&i.Name,
+			&i.Gender,
+			&i.Type,
+			&i.CountryFk,
+			&i.CountryName,
+			&i.OrdinaryTime,
+			&i.RunningScore,
+			&i.Halftime,
+			&i.FinalResult,
+			&i.LastUpdatedAt,
+			&i.CreatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const GetEnetpulseResultRefereesByResultFK = `-- name: GetEnetpulseResultRefereesByResultFK :many
+SELECT id, result_fk, referee_fk, assistant1_referee_fk, assistant2_referee_fk, fourth_referee_fk, var1_referee_fk, var2_referee_fk, last_updated_at, created_at
+FROM enetpulse_result_referees
+WHERE result_fk = $1
+ORDER BY created_at DESC
+`
+
+func (q *Queries) GetEnetpulseResultRefereesByResultFK(ctx context.Context, resultFk string) ([]EnetpulseResultReferee, error) {
+	rows, err := q.db.Query(ctx, GetEnetpulseResultRefereesByResultFK, resultFk)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []EnetpulseResultReferee
+	for rows.Next() {
+		var i EnetpulseResultReferee
+		if err := rows.Scan(
+			&i.ID,
+			&i.ResultFk,
+			&i.RefereeFk,
+			&i.Assistant1RefereeFk,
+			&i.Assistant2RefereeFk,
+			&i.FourthRefereeFk,
+			&i.Var1RefereeFk,
+			&i.Var2RefereeFk,
+			&i.LastUpdatedAt,
+			&i.CreatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const GetFixturesWithPreodds = `-- name: GetFixturesWithPreodds :many
 SELECT
     f.fixture_id AS id,
@@ -1180,7 +1396,6 @@ SELECT
     f.sport_fk,
     f.tournament_fk,
     f.tournament_template_fk,
-    f.tournament_stage_fk,
     f.start_date,
     f.status_type,
     f.status_desc_fk,
@@ -1221,7 +1436,6 @@ type GetFixturesWithPreoddsRow struct {
 	SportFk                string             `json:"sport_fk"`
 	TournamentFk           pgtype.Text        `json:"tournament_fk"`
 	TournamentTemplateFk   pgtype.Text        `json:"tournament_template_fk"`
-	TournamentStageFk      pgtype.Text        `json:"tournament_stage_fk"`
 	StartDate              pgtype.Timestamptz `json:"start_date"`
 	StatusType             pgtype.Text        `json:"status_type"`
 	StatusDescFk           pgtype.Text        `json:"status_desc_fk"`
@@ -1264,7 +1478,6 @@ func (q *Queries) GetFixturesWithPreodds(ctx context.Context) ([]GetFixturesWith
 			&i.SportFk,
 			&i.TournamentFk,
 			&i.TournamentTemplateFk,
-			&i.TournamentStageFk,
 			&i.StartDate,
 			&i.StatusType,
 			&i.StatusDescFk,
diff --git a/gen/db/models.go b/gen/db/models.go
index a3b349a..dd3f35e 100644
--- a/gen/db/models.go
+++ b/gen/db/models.go
@@ -264,8 +264,6 @@ type EnetpulseFixture struct {
 	SportFk                string             `json:"sport_fk"`
 	TournamentFk           pgtype.Text        `json:"tournament_fk"`
 	TournamentTemplateFk   pgtype.Text        `json:"tournament_template_fk"`
-	TournamentStageFk      pgtype.Text        `json:"tournament_stage_fk"`
-	TournamentStageName    pgtype.Text        `json:"tournament_stage_name"`
 	TournamentName         pgtype.Text        `json:"tournament_name"`
 	TournamentTemplateName pgtype.Text        `json:"tournament_template_name"`
 	SportName              pgtype.Text        `json:"sport_name"`
@@ -333,8 +331,6 @@ type EnetpulseResult struct {
 	SportFk                string             `json:"sport_fk"`
 	TournamentFk           pgtype.Text        `json:"tournament_fk"`
 	TournamentTemplateFk   pgtype.Text        `json:"tournament_template_fk"`
-	TournamentStageFk      pgtype.Text        `json:"tournament_stage_fk"`
-	TournamentStageName    pgtype.Text        `json:"tournament_stage_name"`
 	TournamentName         pgtype.Text        `json:"tournament_name"`
 	TournamentTemplateName pgtype.Text        `json:"tournament_template_name"`
 	SportName              pgtype.Text        `json:"sport_name"`
diff --git a/internal/domain/enet_pulse.go b/internal/domain/enet_pulse.go
index 6a5881a..78bcf77 100644
--- a/internal/domain/enet_pulse.go
+++ b/internal/domain/enet_pulse.go
@@ -121,9 +121,9 @@ type TournamentStageParticipantsResponse struct {
 }
 
 type DailyEventsRequest struct {
-	SportFK                int // one of these three required
-	TournamentTemplateFK   int
-	TournamentStageFK      int
+	SportFK              int // one of these three required
+	TournamentTemplateFK int
+	// TournamentStageFK      int
 	Date                   string // YYYY-MM-DD optional
 	Live                   string // yes/no optional
 	IncludeVenue           string // yes/no optional
@@ -145,9 +145,9 @@ type DailyEventsResponse struct {
 }
 
 type FixturesRequest struct {
-	SportFK                int
-	TournamentTemplateFK   int
-	TournamentStageFK      int
+	SportFK              int
+	TournamentTemplateFK int
+	// TournamentStageFK      int
 	LanguageTypeFK         int
 	Date                   string // YYYY-MM-DD
 	Live                   string // "yes" | "no"
@@ -170,9 +170,9 @@ type FixtureEvent struct {
 }
 
 type ResultsRequest struct {
-	SportFK                int
-	TournamentTemplateFK   int
-	TournamentStageFK      int
+	SportFK              int
+	TournamentTemplateFK int
+	// TournamentStageFK      int
 	LanguageTypeFK         int
 	Date                   string // YYYY-MM-DD
 	Live                   string // "yes" | "no"
@@ -224,8 +224,8 @@ type EventDetailsResponse struct {
 }
 
 type EventListRequest struct {
-	TournamentFK           int    // optional
-	TournamentStageFK      int    // optional
+	TournamentFK int // optional
+	// TournamentStageFK      int    // optional
 	IncludeEventProperties bool   // default true
 	StatusType             string // e.g. "finished", "inprogress"
 	IncludeVenue           bool
@@ -250,11 +250,11 @@ type ParticipantFixturesRequest struct {
 	SportFK              int
 	TournamentFK         int
 	TournamentTemplateFK int
-	TournamentStageFK    int
-	Date                 string
-	Live                 string
-	Limit                int
-	Offset               int
+	// TournamentStageFK    int
+	Date   string
+	Live   string
+	Limit  int
+	Offset int
 
 	IncludeVenue           bool
 	IncludeCountryCodes    bool
@@ -486,32 +486,32 @@ type CreateEnetpulseFixture struct {
 
 // Full domain model
 type EnetpulseFixture struct {
-	FixtureID              string            `json:"id"`
-	Name                   string            `json:"name"`
-	SportFK                string            `json:"sportFK"`
-	TournamentFK           string            `json:"tournamentFK"`
-	TournamentTemplateFK   string            `json:"tournament_templateFK"`
-	TournamentStageFK      string            `json:"tournament_stageFK"`
-	TournamentStageName    string            `json:"tournament_stage_name"`
-	TournamentName         string            `json:"tournament_name"`
-	TournamentTemplateName string            `json:"tournament_template_name"`
-	SportName              string            `json:"sport_name"`
-	Gender                 string            `json:"gender"`
-	StartDate              string            `json:"startdate"`     // ISO 8601
-	StatusType             string            `json:"status_type"`
-	StatusDescFK           string            `json:"status_descFK"`
-	RoundTypeFK            string            `json:"round_typeFK"`
-	UpdatesCount           string            `json:"n"`             // convert to int
-	LastUpdatedAt          string            `json:"ut"`            // parse to time.Time
+	FixtureID            string `json:"id"`
+	Name                 string `json:"name"`
+	SportFK              string `json:"sportFK"`
+	TournamentFK         string `json:"tournamentFK"`
+	TournamentTemplateFK string `json:"tournament_templateFK"`
+	// TournamentStageFK      string            `json:"tournament_stageFK"`
+	TournamentStageName    string `json:"tournament_stage_name"`
+	TournamentName         string `json:"tournament_name"`
+	TournamentTemplateName string `json:"tournament_template_name"`
+	SportName              string `json:"sport_name"`
+	Gender                 string `json:"gender"`
+	StartDate              string `json:"startdate"` // ISO 8601
+	StatusType             string `json:"status_type"`
+	StatusDescFK           string `json:"status_descFK"`
+	RoundTypeFK            string `json:"round_typeFK"`
+	UpdatesCount           string `json:"n"`  // convert to int
+	LastUpdatedAt          string `json:"ut"` // parse to time.Time
 }
 
 type CreateEnetpulseResult struct {
-	ResultID               string    `json:"result_id"`
-	Name                   string    `json:"name"`
-	SportFK                string    `json:"sport_fk"`
-	TournamentFK           string    `json:"tournament_fk"`
-	TournamentTemplateFK   string    `json:"tournament_template_fk"`
-	TournamentStageFK      string    `json:"tournament_stage_fk"`
+	ResultID             string `json:"result_id"`
+	Name                 string `json:"name"`
+	SportFK              string `json:"sport_fk"`
+	TournamentFK         string `json:"tournament_fk"`
+	TournamentTemplateFK string `json:"tournament_template_fk"`
+	// TournamentStageFK      string    `json:"tournament_stage_fk"`
 	TournamentStageName    string    `json:"tournament_stage_name"`
 	TournamentName         string    `json:"tournament_name"`
 	TournamentTemplateName string    `json:"tournament_template_name"`
@@ -544,13 +544,13 @@ type CreateEnetpulseResult struct {
 
 // ✅ Used for reading result records
 type EnetpulseResult struct {
-	ID                     int64      `json:"id"`
-	ResultID               string     `json:"result_id"`
-	Name                   string     `json:"name"`
-	SportFK                string     `json:"sport_fk"`
-	TournamentFK           string     `json:"tournament_fk"`
-	TournamentTemplateFK   string     `json:"tournament_template_fk"`
-	TournamentStageFK      string     `json:"tournament_stage_fk"`
+	ID                   int64  `json:"id"`
+	ResultID             string `json:"result_id"`
+	Name                 string `json:"name"`
+	SportFK              string `json:"sport_fk"`
+	TournamentFK         string `json:"tournament_fk"`
+	TournamentTemplateFK string `json:"tournament_template_fk"`
+	// TournamentStageFK      string     `json:"tournament_stage_fk"`
 	TournamentStageName    string     `json:"tournament_stage_name"`
 	TournamentName         string     `json:"tournament_name"`
 	TournamentTemplateName string     `json:"tournament_template_name"`
@@ -704,3 +704,65 @@ type EnetpulsePreodds struct {
 	CreatedAt              time.Time
 	UpdatedAt              time.Time
 }
+
+type EnetpulseResultParticipant struct {
+	ID               int64     `json:"id"`
+	ParticipantMapID string    `json:"participant_map_id"`
+	ResultFk         string    `json:"result_fk"`
+	ParticipantFk    string    `json:"participant_fk"`
+	Number           int32     `json:"number"`
+	Name             string    `json:"name"`
+	Gender           string    `json:"gender"`
+	Type             string    `json:"type"`
+	CountryFk        string    `json:"country_fk"`
+	CountryName      string    `json:"country_name"`
+	OrdinaryTime     string    `json:"ordinary_time"`
+	RunningScore     string    `json:"running_score"`
+	Halftime         string    `json:"halftime"`
+	FinalResult      string    `json:"final_result"`
+	LastUpdatedAt    time.Time `json:"last_updated_at"`
+	CreatedAt        time.Time `json:"created_at"`
+}
+
+// CreateEnetpulseResultParticipant is the payload for inserting or updating a participant record.
+type CreateEnetpulseResultParticipant struct {
+	ParticipantMapID string    `json:"participant_map_id"`
+	ResultFk         string    `json:"result_fk"`
+	ParticipantFk    string    `json:"participant_fk"`
+	Number           int32     `json:"number"`
+	Name             string    `json:"name"`
+	Gender           string    `json:"gender"`
+	Type             string    `json:"type"`
+	CountryFk        string    `json:"country_fk"`
+	CountryName      string    `json:"country_name"`
+	OrdinaryTime     string    `json:"ordinary_time"`
+	RunningScore     string    `json:"running_score"`
+	Halftime         string    `json:"halftime"`
+	FinalResult      string    `json:"final_result"`
+	LastUpdatedAt    time.Time `json:"last_updated_at"`
+}
+
+type EnetpulseResultReferee struct {
+	ID                  int64     `json:"id"`
+	ResultFk            string    `json:"result_fk"`
+	RefereeFk           string    `json:"referee_fk"`
+	Assistant1RefereeFk string    `json:"assistant1_referee_fk"`
+	Assistant2RefereeFk string    `json:"assistant2_referee_fk"`
+	FourthRefereeFk     string    `json:"fourth_referee_fk"`
+	Var1RefereeFk       string    `json:"var1_referee_fk"`
+	Var2RefereeFk       string    `json:"var2_referee_fk"`
+	LastUpdatedAt       time.Time `json:"last_updated_at"`
+	CreatedAt           time.Time `json:"created_at"`
+}
+
+// CreateEnetpulseResultReferee is the payload for inserting or updating referee assignments.
+type CreateEnetpulseResultReferee struct {
+	ResultFk            string    `json:"result_fk"`
+	RefereeFk           string    `json:"referee_fk"`
+	Assistant1RefereeFk string    `json:"assistant1_referee_fk"`
+	Assistant2RefereeFk string    `json:"assistant2_referee_fk"`
+	FourthRefereeFk     string    `json:"fourth_referee_fk"`
+	Var1RefereeFk       string    `json:"var1_referee_fk"`
+	Var2RefereeFk       string    `json:"var2_referee_fk"`
+	LastUpdatedAt       time.Time `json:"last_updated_at"`
+}
diff --git a/internal/repository/enet_pulse.go b/internal/repository/enet_pulse.go
index b66e225..2dc99a9 100644
--- a/internal/repository/enet_pulse.go
+++ b/internal/repository/enet_pulse.go
@@ -321,16 +321,16 @@ func (s *Store) GetFixturesWithPreodds(ctx context.Context) ([]domain.EnetpulseF
 				SportFk:              row.SportFk,
 				TournamentFk:         row.TournamentFk.String,
 				TournamentTemplateFk: row.TournamentTemplateFk.String,
-				TournamentStageFk:    row.TournamentStageFk.String,
-				StartDate:            row.StartDate.Time,
-				StatusType:           row.StatusType.String,
-				StatusDescFk:         row.StatusDescFk.String,
-				RoundTypeFk:          row.RoundTypeFk.String,
-				UpdatesCount:         row.FixtureUpdatesCount.Int32,
-				LastUpdatedAt:        row.FixtureLastUpdatedAt.Time,
-				CreatedAt:            row.FixtureCreatedAt.Time,
-				UpdatedAt:            row.FixtureUpdatedAt.Time,
-				Preodds:              []domain.EnetpulsePreodds{}, // initialize slice
+				// TournamentStageFk:    row.TournamentStageFk.String,
+				StartDate:     row.StartDate.Time,
+				StatusType:    row.StatusType.String,
+				StatusDescFk:  row.StatusDescFk.String,
+				RoundTypeFk:   row.RoundTypeFk.String,
+				UpdatesCount:  row.FixtureUpdatesCount.Int32,
+				LastUpdatedAt: row.FixtureLastUpdatedAt.Time,
+				CreatedAt:     row.FixtureCreatedAt.Time,
+				UpdatedAt:     row.FixtureUpdatedAt.Time,
+				Preodds:       []domain.EnetpulsePreodds{}, // initialize slice
 			}
 		}
 
@@ -387,13 +387,13 @@ func (s *Store) GetFixturesWithPreodds(ctx context.Context) ([]domain.EnetpulseF
 // ConvertCreateEnetpulseFixture converts the domain model to the SQLC params struct.
 func ConvertCreateEnetpulseFixture(f domain.CreateEnetpulseFixture) dbgen.CreateEnetpulseFixtureParams {
 	return dbgen.CreateEnetpulseFixtureParams{
-		FixtureID:              f.FixtureID,
-		Name:                   f.Name,
-		SportFk:                f.SportFK,
-		TournamentFk:           pgtype.Text{String: f.TournamentFK, Valid: f.TournamentFK != ""},
-		TournamentTemplateFk:   pgtype.Text{String: f.TournamentTemplateFK, Valid: f.TournamentTemplateFK != ""},
-		TournamentStageFk:      pgtype.Text{String: f.TournamentStageFK, Valid: f.TournamentStageFK != ""},
-		TournamentStageName:    pgtype.Text{String: f.TournamentStageName, Valid: f.TournamentStageName != ""},
+		FixtureID:            f.FixtureID,
+		Name:                 f.Name,
+		SportFk:              f.SportFK,
+		TournamentFk:         pgtype.Text{String: f.TournamentFK, Valid: f.TournamentFK != ""},
+		TournamentTemplateFk: pgtype.Text{String: f.TournamentTemplateFK, Valid: f.TournamentTemplateFK != ""},
+		// TournamentStageFk:      pgtype.Text{String: f.TournamentStageFK, Valid: f.TournamentStageFK != ""},
+		// TournamentStageName:    pgtype.Text{String: f.TournamentStageName, Valid: f.TournamentStageName != ""},
 		TournamentName:         pgtype.Text{String: f.TournamentName, Valid: f.TournamentName != ""},
 		TournamentTemplateName: pgtype.Text{String: f.TournamentTemplateName, Valid: f.TournamentTemplateName != ""},
 		SportName:              pgtype.Text{String: f.SportName, Valid: f.SportName != ""},
@@ -410,13 +410,13 @@ func ConvertCreateEnetpulseFixture(f domain.CreateEnetpulseFixture) dbgen.Create
 // ConvertDBEnetpulseFixture converts the DB row to the domain model.
 func ConvertDBEnetpulseFixture(dbF dbgen.EnetpulseFixture) domain.EnetpulseFixture {
 	return domain.EnetpulseFixture{
-		FixtureID:              dbF.FixtureID,
-		Name:                   dbF.Name,
-		SportFK:                dbF.SportFk,
-		TournamentFK:           dbF.TournamentFk.String,
-		TournamentTemplateFK:   dbF.TournamentTemplateFk.String,
-		TournamentStageFK:      dbF.TournamentStageFk.String,
-		TournamentStageName:    dbF.TournamentStageName.String,
+		FixtureID:            dbF.FixtureID,
+		Name:                 dbF.Name,
+		SportFK:              dbF.SportFk,
+		TournamentFK:         dbF.TournamentFk.String,
+		TournamentTemplateFK: dbF.TournamentTemplateFk.String,
+		// TournamentStageFK:      dbF.TournamentStageFk.String,
+		// TournamentStageName:    dbF.TournamentStageName.String,
 		TournamentName:         dbF.TournamentName.String,
 		TournamentTemplateName: dbF.TournamentTemplateName.String,
 		SportName:              dbF.SportName.String,
@@ -599,13 +599,13 @@ func ConvertDBEnetpulseTournament(dbT dbgen.EnetpulseTournament) domain.Enetpuls
 
 func ConvertCreateEnetpulseResult(input domain.CreateEnetpulseResult) dbgen.CreateEnetpulseResultParams {
 	return dbgen.CreateEnetpulseResultParams{
-		ResultID:               input.ResultID,
-		Name:                   input.Name,
-		SportFk:                input.SportFK,
-		TournamentFk:           pgtype.Text{String: input.TournamentFK, Valid: input.TournamentFK != ""},
-		TournamentTemplateFk:   pgtype.Text{String: input.TournamentTemplateFK, Valid: input.TournamentTemplateFK != ""},
-		TournamentStageFk:      pgtype.Text{String: input.TournamentStageFK, Valid: input.TournamentStageFK != ""},
-		TournamentStageName:    pgtype.Text{String: input.TournamentStageName, Valid: input.TournamentStageName != ""},
+		ResultID:             input.ResultID,
+		Name:                 input.Name,
+		SportFk:              input.SportFK,
+		TournamentFk:         pgtype.Text{String: input.TournamentFK, Valid: input.TournamentFK != ""},
+		TournamentTemplateFk: pgtype.Text{String: input.TournamentTemplateFK, Valid: input.TournamentTemplateFK != ""},
+		// TournamentStageFk:      pgtype.Text{String: input.TournamentStageFK, Valid: input.TournamentStageFK != ""},
+		// TournamentStageName:    pgtype.Text{String: input.TournamentStageName, Valid: input.TournamentStageName != ""},
 		TournamentName:         pgtype.Text{String: input.TournamentName, Valid: input.TournamentName != ""},
 		TournamentTemplateName: pgtype.Text{String: input.TournamentTemplateName, Valid: input.TournamentTemplateName != ""},
 		SportName:              pgtype.Text{String: input.SportName, Valid: input.SportName != ""},
@@ -635,14 +635,14 @@ func ConvertCreateEnetpulseResult(input domain.CreateEnetpulseResult) dbgen.Crea
 // ConvertDBEnetpulseResult maps SQLC result → domain model
 func ConvertDBEnetpulseResult(db dbgen.EnetpulseResult) domain.EnetpulseResult {
 	return domain.EnetpulseResult{
-		ID:                     db.ID,
-		ResultID:               db.ResultID,
-		Name:                   db.Name,
-		SportFK:                db.SportFk,
-		TournamentFK:           db.TournamentFk.String,
-		TournamentTemplateFK:   db.TournamentTemplateFk.String,
-		TournamentStageFK:      db.TournamentStageFk.String,
-		TournamentStageName:    db.TournamentStageName.String,
+		ID:                   db.ID,
+		ResultID:             db.ResultID,
+		Name:                 db.Name,
+		SportFK:              db.SportFk,
+		TournamentFK:         db.TournamentFk.String,
+		TournamentTemplateFK: db.TournamentTemplateFk.String,
+		// TournamentStageFK:      db.TournamentStageFk.String,
+		// TournamentStageName:    db.TournamentStageName.String,
 		TournamentName:         db.TournamentName.String,
 		TournamentTemplateName: db.TournamentTemplateName.String,
 		SportName:              db.SportName.String,
@@ -815,3 +815,135 @@ func ConvertDBEnetpulsePreoddsBettingOffer(o dbgen.EnetpulsePreoddsBettingoffer)
 		UpdatedAt:            o.UpdatedAt.Time,
 	}
 }
+
+func (s *Store) CreateEnetpulseResultParticipant(
+	ctx context.Context,
+	participant domain.CreateEnetpulseResultParticipant,
+) (domain.EnetpulseResultParticipant, error) {
+	dbParticipant, err := s.queries.CreateEnetpulseResultParticipant(
+		ctx,
+		ConvertCreateEnetpulseResultParticipant(participant),
+	)
+	if err != nil {
+		return domain.EnetpulseResultParticipant{}, err
+	}
+
+	return ConvertDBEnetpulseResultParticipant(dbParticipant), nil
+}
+
+func (s *Store) GetEnetpulseResultParticipantsByResultFK(
+	ctx context.Context,
+	resultFK string,
+) ([]domain.EnetpulseResultParticipant, error) {
+	dbParticipants, err := s.queries.GetEnetpulseResultParticipantsByResultFK(ctx, resultFK)
+	if err != nil {
+		return nil, err
+	}
+
+	participants := make([]domain.EnetpulseResultParticipant, 0, len(dbParticipants))
+	for _, dbp := range dbParticipants {
+		participants = append(participants, ConvertDBEnetpulseResultParticipant(dbp))
+	}
+
+	return participants, nil
+}
+
+func (s *Store) CreateEnetpulseResultReferee(
+	ctx context.Context,
+	referee domain.CreateEnetpulseResultReferee,
+) (domain.EnetpulseResultReferee, error) {
+	dbReferee, err := s.queries.CreateEnetpulseResultReferee(
+		ctx,
+		ConvertCreateEnetpulseResultReferee(referee),
+	)
+	if err != nil {
+		return domain.EnetpulseResultReferee{}, err
+	}
+
+	return ConvertDBEnetpulseResultReferee(dbReferee), nil
+}
+
+func (s *Store) GetEnetpulseResultRefereesByResultFK(
+	ctx context.Context,
+	resultFK string,
+) ([]domain.EnetpulseResultReferee, error) {
+	dbReferees, err := s.queries.GetEnetpulseResultRefereesByResultFK(ctx, resultFK)
+	if err != nil {
+		return nil, err
+	}
+
+	referees := make([]domain.EnetpulseResultReferee, 0, len(dbReferees))
+	for _, dbr := range dbReferees {
+		referees = append(referees, ConvertDBEnetpulseResultReferee(dbr))
+	}
+
+	return referees, nil
+}
+
+func ConvertCreateEnetpulseResultParticipant(p domain.CreateEnetpulseResultParticipant) dbgen.CreateEnetpulseResultParticipantParams {
+	return dbgen.CreateEnetpulseResultParticipantParams{
+		ParticipantMapID: p.ParticipantMapID,
+		ResultFk:         p.ResultFk,
+		ParticipantFk:    p.ParticipantFk,
+		Number:           pgtype.Int4{Int32: p.Number},
+		Name:             pgtype.Text{String: p.Name},
+		Gender:           pgtype.Text{String: p.Gender},
+		Type:             pgtype.Text{String: p.Type},
+		CountryFk:        pgtype.Text{String: p.CountryFk},
+		CountryName:      pgtype.Text{String: p.CountryName},
+		OrdinaryTime:     pgtype.Text{String: p.OrdinaryTime},
+		RunningScore:     pgtype.Text{String: p.RunningScore},
+		Halftime:         pgtype.Text{String: p.Halftime},
+		FinalResult:      pgtype.Text{String: p.FinalResult},
+		LastUpdatedAt:    pgtype.Timestamptz{Time: p.LastUpdatedAt, Valid: !p.LastUpdatedAt.IsZero()},
+	}
+}
+
+func ConvertDBEnetpulseResultParticipant(p dbgen.EnetpulseResultParticipant) domain.EnetpulseResultParticipant {
+	return domain.EnetpulseResultParticipant{
+		ID:               p.ID,
+		ParticipantMapID: p.ParticipantMapID,
+		ResultFk:         p.ResultFk,
+		ParticipantFk:    p.ParticipantFk,
+		Number:           p.Number.Int32,
+		Name:             p.Name.String,
+		Gender:           p.Gender.String,
+		Type:             p.Type.String,
+		CountryFk:        p.CountryFk.String,
+		CountryName:      p.CountryName.String,
+		OrdinaryTime:     p.OrdinaryTime.String,
+		RunningScore:     p.RunningScore.String,
+		Halftime:         p.Halftime.String,
+		FinalResult:      p.FinalResult.String,
+		LastUpdatedAt:    p.LastUpdatedAt.Time,
+		CreatedAt:        p.CreatedAt.Time,
+	}
+}
+
+func ConvertCreateEnetpulseResultReferee(r domain.CreateEnetpulseResultReferee) dbgen.CreateEnetpulseResultRefereeParams {
+	return dbgen.CreateEnetpulseResultRefereeParams{
+		ResultFk:            r.ResultFk,
+		RefereeFk:           pgtype.Text{String: r.RefereeFk},
+		Assistant1RefereeFk: pgtype.Text{String: r.Assistant1RefereeFk},
+		Assistant2RefereeFk: pgtype.Text{String: r.Assistant2RefereeFk},
+		FourthRefereeFk:     pgtype.Text{String: r.FourthRefereeFk},
+		Var1RefereeFk:       pgtype.Text{String: r.Var1RefereeFk},
+		Var2RefereeFk:       pgtype.Text{String: r.Var2RefereeFk},
+		LastUpdatedAt:       pgtype.Timestamptz{Time: r.LastUpdatedAt},
+	}
+}
+
+func ConvertDBEnetpulseResultReferee(r dbgen.EnetpulseResultReferee) domain.EnetpulseResultReferee {
+	return domain.EnetpulseResultReferee{
+		ID:                  r.ID,
+		ResultFk:            r.ResultFk,
+		RefereeFk:           r.RefereeFk.String,
+		Assistant1RefereeFk: r.Assistant1RefereeFk.String,
+		Assistant2RefereeFk: r.Assistant2RefereeFk.String,
+		FourthRefereeFk:     r.FourthRefereeFk.String,
+		Var1RefereeFk:       r.Var1RefereeFk.String,
+		Var2RefereeFk:       r.Var2RefereeFk.String,
+		LastUpdatedAt:       r.LastUpdatedAt.Time,
+		CreatedAt:           r.CreatedAt.Time	,
+	}
+}
diff --git a/internal/services/enet_pulse/service.go b/internal/services/enet_pulse/service.go
index ed31572..2fa4304 100644
--- a/internal/services/enet_pulse/service.go
+++ b/internal/services/enet_pulse/service.go
@@ -479,12 +479,12 @@ func (s *Service) FetchAndStoreFixtures(ctx context.Context, date string) error
 		TournamentTemplateName string `json:"tournament_template_name"`
 		SportName              string `json:"sport_name"`
 		Gender                 string `json:"gender"`
-		StartDate              string `json:"startdate"`  // ISO 8601
+		StartDate              string `json:"startdate"` // ISO 8601
 		StatusType             string `json:"status_type"`
 		StatusDescFK           string `json:"status_descFK"`
 		RoundTypeFK            string `json:"round_typeFK"`
-		UpdatesCount           string `json:"n"`         // convert to int
-		LastUpdatedAt          string `json:"ut"`        // parse to time.Time
+		UpdatesCount           string `json:"n"`  // convert to int
+		LastUpdatedAt          string `json:"ut"` // parse to time.Time
 	}
 
 	// 2️⃣ Loop through each sport
@@ -585,130 +585,6 @@ func (s *Service) FetchAndStoreFixtures(ctx context.Context, date string) error
 	return nil
 }
 
-
-// func (s *Service) FetchFixtures(ctx context.Context, date string) ([]domain.EnetpulseFixture, error) {
-// 	var allFixtures []domain.EnetpulseFixture
-
-// 	// 1️⃣ Fetch all sports from the database
-// 	sports, err := s.store.GetAllEnetpulseSports(ctx)
-// 	if err != nil {
-// 		return nil, fmt.Errorf("failed to fetch sports from DB: %w", err)
-// 	}
-
-// 	// Struct for decoding each fixture from API
-// 	type Fixture struct {
-// 		FixtureID              string `json:"id"`
-// 		Name                   string `json:"name"`
-// 		SportFK                string `json:"sportFK"`
-// 		TournamentFK           string `json:"tournamentFK"`
-// 		TournamentTemplateFK   string `json:"tournament_templateFK"`
-// 		TournamentStageFK      string `json:"tournament_stageFK"`
-// 		TournamentStageName    string `json:"tournament_stage_name"`
-// 		TournamentName         string `json:"tournament_name"`
-// 		TournamentTemplateName string `json:"tournament_template_name"`
-// 		SportName              string `json:"sport_name"`
-// 		Gender                 string `json:"gender"`
-// 		StartDate              string `json:"startdate"`
-// 		StatusType             string `json:"status_type"`
-// 		StatusDescFK           string `json:"status_descFK"`
-// 		RoundTypeFK            string `json:"round_typeFK"`
-// 		UpdatesCount           string `json:"n"`
-// 		LastUpdatedAt          string `json:"ut"`
-// 	}
-
-// 	// 2️⃣ Loop through each sport
-// 	for _, sport := range sports {
-// 		// Only fetch for sport "1" (Football)
-// 		if sport.SportID != "1" {
-// 			continue
-// 		}
-
-// 		url := fmt.Sprintf(
-// 			"http://eapi.enetpulse.com/event/fixtures/?username=%s&token=%s&sportFK=%s&language_typeFK=3&date=%s",
-// 			s.cfg.EnetPulseConfig.UserName,
-// 			s.cfg.EnetPulseConfig.Token,
-// 			sport.SportID,
-// 			date,
-// 		)
-
-// 		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-// 		if err != nil {
-// 			fmt.Printf("creating fixtures request for sport %s: %v\n", sport.SportID, err)
-// 			continue
-// 		}
-
-// 		resp, err := s.httpClient.Do(req)
-// 		if err != nil {
-// 			fmt.Printf("requesting fixtures for sport %s: %v\n", sport.SportID, err)
-// 			continue
-// 		}
-// 		defer resp.Body.Close()
-
-// 		if resp.StatusCode != http.StatusOK {
-// 			body, _ := io.ReadAll(resp.Body)
-// 			fmt.Printf("failed to fetch fixtures for sport %s (status %d): %s\n",
-// 				sport.SportID, resp.StatusCode, string(body))
-// 			continue
-// 		}
-
-// 		// 3️⃣ Decode API response
-// 		var fixturesResp struct {
-// 			Events map[string]Fixture `json:"events"`
-// 		}
-// 		if err := json.NewDecoder(resp.Body).Decode(&fixturesResp); err != nil {
-// 			fmt.Printf("decoding fixtures response for sport %s: %v\n", sport.SportID, err)
-// 			continue
-// 		}
-
-// 		// 4️⃣ Iterate over fixtures and store them
-// 		for _, fx := range fixturesResp.Events {
-// 			tournamentFK, _ := strconv.Atoi(fx.TournamentFK)
-// 			tournamentTemplateFK, _ := strconv.Atoi(fx.TournamentTemplateFK)
-// 			tournamentStageFK, _ := strconv.Atoi(fx.TournamentStageFK)
-// 			statusDescFK, _ := strconv.Atoi(fx.StatusDescFK)
-// 			roundTypeFK, _ := strconv.Atoi(fx.RoundTypeFK)
-// 			updatesCount, _ := strconv.Atoi(fx.UpdatesCount)
-
-// 			startDate, _ := time.Parse(time.RFC3339, fx.StartDate)
-// 			lastUpdatedAt, _ := time.Parse(time.RFC3339, fx.LastUpdatedAt)
-
-// 			createFixture := domain.CreateEnetpulseFixture{
-// 				FixtureID:              fx.FixtureID,
-// 				Name:                   fx.Name,
-// 				SportFK:                fx.SportFK,
-// 				TournamentFK:           strconv.Itoa(tournamentFK),
-// 				TournamentTemplateFK:   strconv.Itoa(tournamentTemplateFK),
-// 				TournamentStageFK:      strconv.Itoa(tournamentStageFK),
-// 				TournamentStageName:    fx.TournamentStageName,
-// 				TournamentName:         fx.TournamentName,
-// 				TournamentTemplateName: fx.TournamentTemplateName,
-// 				SportName:              fx.SportName,
-// 				Gender:                 fx.Gender,
-// 				StartDate:              startDate,
-// 				StatusType:             fx.StatusType,
-// 				StatusDescFK:           strconv.Itoa(statusDescFK),
-// 				RoundTypeFK:            strconv.Itoa(roundTypeFK),
-// 				UpdatesCount:           updatesCount,
-// 				LastUpdatedAt:          lastUpdatedAt,
-// 			}
-
-// 			dbFixture, err := s.store.CreateEnetpulseFixture(ctx, createFixture)
-// 			if err != nil {
-// 				fmt.Printf("failed storing fixture %s: %v\n", fx.FixtureID, err)
-// 				continue
-// 			}
-
-// 			allFixtures = append(allFixtures, dbFixture)
-// 		}
-
-// 		// fmt.Printf("✅ Successfully fetched and stored fixtures for sport %s\n", sport.SportID)
-// 		break // stop after first relevant sport
-// 	}
-
-// 	// fmt.Println("✅ Completed fetching and storing fixtures for all sports")
-// 	return allFixtures, nil
-// }
-
 func (s *Service) GetAllFixtures(ctx context.Context) ([]domain.EnetpulseFixture, error) {
 	// 1️⃣ Fetch all from store
 	fixtures, err := s.store.GetAllEnetpulseFixtures(ctx)
@@ -719,59 +595,24 @@ func (s *Service) GetAllFixtures(ctx context.Context) ([]domain.EnetpulseFixture
 }
 
 func (s *Service) FetchAndStoreResults(ctx context.Context) error {
-	// 1️⃣ Fetch all sports (if you want to limit to one, adjust the loop as in your template fetcher)
 	sports, err := s.store.GetAllEnetpulseSports(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to fetch sports from DB: %w", err)
 	}
 
-	type Result struct {
-		ID                     string `json:"id"`
-		Name                   string `json:"name"`
-		SportFK                string `json:"sportFK"`
-		TournamentFK           string `json:"tournamentFK"`
-		TournamentTemplateFK   string `json:"tournament_templateFK"`
-		TournamentStageFK      string `json:"tournament_stageFK"`
-		TournamentStageName    string `json:"tournament_stage_name"`
-		TournamentName         string `json:"tournament_name"`
-		TournamentTemplateName string `json:"tournament_template_name"`
-		SportName              string `json:"sport_name"`
-		StartDate              string `json:"startdate"`
-		StatusType             string `json:"status_type"`
-		StatusDescFK           string `json:"status_descFK"`
-		RoundTypeFK            string `json:"round_typeFK"`
-		N                      string `json:"n"`
-		UT                     string `json:"ut"`
-		Round                  string `json:"round"`
-		Live                   string `json:"live"`
-		VenueName              string `json:"venue_name"`
-		LivestatsPlus          string `json:"livestats_plus"`
-		LivestatsType          string `json:"livestats_type"`
-		Commentary             string `json:"commentary"`
-		LineupConfirmed        bool   `json:"lineup_confirmed"`
-		Verified               bool   `json:"verified"`
-		Spectators             int32  `json:"spectators"`
-		GameStarted            string `json:"game_started"`
-		FirstHalfEnded         string `json:"first_half_ended"`
-		SecondHalfStarted      string `json:"second_half_started"`
-		SecondHalfEnded        string `json:"second_half_ended"`
-		GameEnded              string `json:"game_ended"`
-	}
-
 	for _, sport := range sports {
-		if sport.SportID != "1" { // ⚽ Example: Only Football
+		if sport.SportID != "1" {
 			continue
 		}
 
+		today := time.Now().Format("2006-01-02")
 		url := fmt.Sprintf(
-			// "https://eapi.enetpulse.com/event/results/?username=kirubelapiusr&token=b1d35ee5fb8371938c6ca1b4fd6c75cc&sportFK=1&language_typeFK=3&date=2025-10-12"
 			"http://eapi.enetpulse.com/event/results/?sportFK=%s&date=%s&username=%s&token=%s",
 			sport.SportID,
-			time.DateOnly,
+			today,
 			s.cfg.EnetPulseConfig.UserName,
 			s.cfg.EnetPulseConfig.Token,
 		)
-
 		fmt.Println("Fetching results:", url)
 
 		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
@@ -791,87 +632,130 @@ func (s *Service) FetchAndStoreResults(ctx context.Context) error {
 				sport.SportID, resp.StatusCode, string(body))
 		}
 
-		var raw struct {
-			EventResults json.RawMessage `json:"results"`
+		var data struct {
+			Events []struct {
+				ID                     string `json:"id"`
+				Name                   string `json:"name"`
+				SportFK                string `json:"sportFK"`
+				TournamentFK           string `json:"tournamentFK"`
+				TournamentTemplateFK   string `json:"tournament_templateFK"`
+				TournamentStageFK      string `json:"tournament_stageFK"`
+				TournamentStageName    string `json:"tournament_stage_name"`
+				TournamentName         string `json:"tournament_name"`
+				TournamentTemplateName string `json:"tournament_template_name"`
+				SportName              string `json:"sport_name"`
+				StartDate              string `json:"startdate"`
+				StatusType             string `json:"status_type"`
+				StatusDescFK           string `json:"status_descFK"`
+				RoundTypeFK            string `json:"round_typeFK"`
+				N                      string `json:"n"`
+				UT                     string `json:"ut"`
+
+				Property map[string]struct {
+					ID    string `json:"id"`
+					Type  string `json:"type"`
+					Name  string `json:"name"`
+					Value string `json:"value"`
+					N     string `json:"n"`
+					UT    string `json:"ut"`
+				} `json:"property"`
+
+				EventParticipants map[string]struct {
+					ID            string `json:"id"`
+					Number        string `json:"number"`
+					ParticipantFK string `json:"participantFK"`
+					EventFK       string `json:"eventFK"`
+
+					Result map[string]struct {
+						ID                  string `json:"id"`
+						EventParticipantsFK string `json:"event_participantsFK"`
+						ResultTypeFK        string `json:"result_typeFK"`
+						ResultCode          string `json:"result_code"`
+						Value               string `json:"value"`
+						N                   string `json:"n"`
+						UT                  string `json:"ut"`
+					} `json:"result"`
+
+					Participant struct {
+						ID          string `json:"id"`
+						Name        string `json:"name"`
+						Gender      string `json:"gender"`
+						Type        string `json:"type"`
+						CountryFK   string `json:"countryFK"`
+						CountryName string `json:"country_name"`
+					} `json:"participant"`
+				} `json:"event_participants"`
+			} `json:"events"`
 		}
 
-		bodyBytes, err := io.ReadAll(resp.Body)
-		if err != nil {
-			return fmt.Errorf("reading results response for sport %s: %w", sport.SportID, err)
-		}
-		if err := json.Unmarshal(bodyBytes, &raw); err != nil {
-			return fmt.Errorf("unmarshalling raw results for sport %s: %w", sport.SportID, err)
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		if err := json.Unmarshal(bodyBytes, &data); err != nil {
+			return fmt.Errorf("decoding results failed: %w", err)
 		}
 
-		results := map[string]Result{}
-		if len(raw.EventResults) > 0 && raw.EventResults[0] == '{' {
-			if err := json.Unmarshal(raw.EventResults, &results); err != nil {
-				return fmt.Errorf("decoding results (object) for sport %s: %w", sport.SportID, err)
-			}
-		} else {
-			fmt.Printf("No results found for sport %s\n", sport.SportID)
-			continue
-		}
-
-		for _, r := range results {
-			updatesCount := 0
-			if r.N != "" {
-				if n, err := strconv.Atoi(r.N); err == nil {
-					updatesCount = n
-				}
-			}
-
-			lastUpdatedAt, _ := time.Parse(time.RFC3339, r.UT)
-			startDate, _ := time.Parse(time.RFC3339, r.StartDate)
-			gameStarted, _ := time.Parse(time.RFC3339, r.GameStarted)
-			firstHalfEnded, _ := time.Parse(time.RFC3339, r.FirstHalfEnded)
-			secondHalfStarted, _ := time.Parse(time.RFC3339, r.SecondHalfStarted)
-			secondHalfEnded, _ := time.Parse(time.RFC3339, r.SecondHalfEnded)
-			gameEnded, _ := time.Parse(time.RFC3339, r.GameEnded)
+		for _, event := range data.Events {
+			// 1️⃣ Create result record
+			lastUpdatedAt, _ := time.Parse(time.RFC3339, event.UT)
+			startDate, _ := time.Parse(time.RFC3339, event.StartDate)
 
 			createResult := domain.CreateEnetpulseResult{
-				ResultID:               r.ID,
-				Name:                   r.Name,
-				SportFK:                r.SportFK,
-				TournamentFK:           r.TournamentFK,
-				TournamentTemplateFK:   r.TournamentTemplateFK,
-				TournamentStageFK:      r.TournamentStageFK,
-				TournamentStageName:    r.TournamentStageName,
-				TournamentName:         r.TournamentName,
-				TournamentTemplateName: r.TournamentTemplateName,
-				SportName:              r.SportName,
+				ResultID:               event.ID,
+				Name:                   event.Name,
+				SportFK:                event.SportFK,
+				TournamentFK:           event.TournamentFK,
+				TournamentTemplateFK:   event.TournamentTemplateFK,
+				TournamentStageName:    event.TournamentStageName,
+				TournamentName:         event.TournamentName,
+				TournamentTemplateName: event.TournamentTemplateName,
+				SportName:              event.SportName,
 				StartDate:              startDate,
-				StatusType:             r.StatusType,
-				StatusDescFK:           r.StatusDescFK,
-				RoundTypeFK:            r.RoundTypeFK,
-				UpdatesCount:           int32(updatesCount),
+				StatusType:             event.StatusType,
+				StatusDescFK:           event.StatusDescFK,
+				RoundTypeFK:            event.RoundTypeFK,
 				LastUpdatedAt:          lastUpdatedAt,
-				Round:                  r.Round,
-				Live:                   r.Live,
-				VenueName:              r.VenueName,
-				LivestatsPlus:          r.LivestatsPlus,
-				LivestatsType:          r.LivestatsType,
-				Commentary:             r.Commentary,
-				LineupConfirmed:        r.LineupConfirmed,
-				Verified:               r.Verified,
-				Spectators:             r.Spectators,
-				GameStarted:            &gameStarted,
-				FirstHalfEnded:         &firstHalfEnded,
-				SecondHalfStarted:      &secondHalfStarted,
-				SecondHalfEnded:        &secondHalfEnded,
-				GameEnded:              &gameEnded,
 			}
 
 			if _, err := s.store.CreateEnetpulseResult(ctx, createResult); err != nil {
-				fmt.Printf("❌ failed to store result %s: %v\n", r.ID, err)
+				fmt.Printf("❌ failed to store result %s: %v\n", event.ID, err)
 				continue
 			}
+
+			// 2️⃣ Create referees (type == "ref:participant")
+			for _, prop := range event.Property {
+				if strings.HasPrefix(prop.Type, "ref:participant") {
+					refCreatedAt, _ := time.Parse(time.RFC3339, prop.UT)
+					ref := domain.CreateEnetpulseResultReferee{
+						ResultFk:      event.ID,
+						RefereeFk:     prop.Value,
+						LastUpdatedAt: refCreatedAt,
+					}
+					if _, err := s.store.CreateEnetpulseResultReferee(ctx, ref); err != nil {
+						fmt.Printf("⚠️ failed to create referee %s: %v\n", prop.Name, err)
+					}
+				}
+			}
+
+			// 3️⃣ Create participants + their results
+			for _, ep := range event.EventParticipants {
+				p := domain.CreateEnetpulseResultParticipant{
+					ParticipantMapID: ep.ID,
+					ResultFk:         ep.EventFK,
+					ParticipantFk:    ep.ParticipantFK,
+					Name:             ep.Participant.Name,
+					CountryFk:        ep.Participant.CountryFK,
+					CountryName:      ep.Participant.CountryName,
+				}
+				if _, err := s.store.CreateEnetpulseResultParticipant(ctx, p); err != nil {
+					fmt.Printf("⚠️ failed to create participant %s: %v\n", ep.Participant.Name, err)
+					continue
+				}
+			}
 		}
 
-		break // limit to one sport if necessary
+		break // stop after the first sport (football)
 	}
 
-	fmt.Println("✅ Successfully fetched and stored EnetPulse results")
+	fmt.Println("✅ Successfully fetched and stored EnetPulse results + participants + referees")
 	return nil
 }
 
@@ -1077,6 +961,8 @@ func (s *Service) FetchAndStorePreodds(ctx context.Context) error {
 					LastUpdatedAt:          lastUpdatedAt,
 				}
 
+				fmt.Printf("\n\nPreodds are:%v\n\n", createPreodds)
+
 				storedPreodds, err := s.store.CreateEnetpulsePreodds(ctx, createPreodds)
 				if err != nil {
 					continue
@@ -1128,6 +1014,7 @@ func (s *Service) GetAllPreodds(ctx context.Context) ([]domain.EnetpulsePreodds,
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch preodds from DB: %w", err)
 	}
+	fmt.Printf("\n\nFetched Preodds are:%v\n\n", preodds)
 	return preodds, nil
 }
 
@@ -1240,18 +1127,6 @@ func (s *Service) GetFixturesWithPreodds(ctx context.Context) ([]domain.Enetpuls
 	return fixtures, nil
 }
 
-// helper to safely parse string to int32
-// func parseStringToInt32(s string) int32 {
-// 	if s == "" {
-// 		return 0
-// 	}
-// 	i, err := strconv.Atoi(s)
-// 	if err != nil {
-// 		return 0
-// 	}
-// 	return int32(i)
-// }
-
 func (s *Service) FetchTournamentTemplates(ctx context.Context) (*domain.TournamentTemplatesResponse, error) {
 	url := fmt.Sprintf(
 		"http://eapi.enetpulse.com/tournamenttemplate/list/?username=%s&token=%s",
@@ -1501,9 +1376,9 @@ func (s *Service) FetchDailyEvents(ctx context.Context, req domain.DailyEventsRe
 	if req.TournamentTemplateFK != 0 {
 		query += fmt.Sprintf("&tournament_templateFK=%d", req.TournamentTemplateFK)
 	}
-	if req.TournamentStageFK != 0 {
-		query += fmt.Sprintf("&tournament_stageFK=%d", req.TournamentStageFK)
-	}
+	// if req.TournamentStageFK != 0 {
+	// 	query += fmt.Sprintf("&tournament_stageFK=%d", req.TournamentStageFK)
+	// }
 
 	// Optionals
 	if req.Date != "" {
@@ -1557,73 +1432,6 @@ func (s *Service) FetchDailyEvents(ctx context.Context, req domain.DailyEventsRe
 	return &dailyResp, nil
 }
 
-// func (s *Service) FetchFixtures(ctx context.Context, params domain.FixturesRequest) (*domain.FixturesResponse, error) {
-// 	// Build base URL
-// 	url := fmt.Sprintf("http://eapi.enetpulse.com/event/fixtures/?username=%s&token=%s",
-// 		s.cfg.EnetPulseConfig.UserName, s.cfg.EnetPulseConfig.Token)
-
-// 	// Required filter: one of sportFK | tournament_templateFK | tournament_stageFK
-// 	if params.SportFK != 0 {
-// 		url += fmt.Sprintf("&sportFK=%d", params.SportFK)
-// 	}
-// 	if params.TournamentTemplateFK != 0 {
-// 		url += fmt.Sprintf("&tournament_templateFK=%d", params.TournamentTemplateFK)
-// 	}
-// 	if params.TournamentStageFK != 0 {
-// 		url += fmt.Sprintf("&tournament_stageFK=%d", params.TournamentStageFK)
-// 	}
-
-// 	// Optional filters
-// 	if params.LanguageTypeFK != 0 {
-// 		url += fmt.Sprintf("&language_typeFK=%d", params.LanguageTypeFK)
-// 	} else {
-// 		url += "&language_typeFK=3" // default to English
-// 	}
-// 	if params.Date != "" {
-// 		url += fmt.Sprintf("&date=%s", params.Date)
-// 	}
-// 	if params.Live != "" {
-// 		url += fmt.Sprintf("&live=%s", params.Live)
-// 	}
-// 	if params.IncludeVenue {
-// 		url += "&includeVenue=yes"
-// 	}
-// 	if !params.IncludeEventProperties {
-// 		url += "&includeEventProperties=no"
-// 	}
-// 	if params.IncludeCountryCodes {
-// 		url += "&includeCountryCodes=yes"
-// 	}
-// 	if params.IncludeFirstLastName {
-// 		url += "&includeFirstLastName=yes"
-// 	}
-
-// 	// Make request
-// 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-// 	if err != nil {
-// 		return nil, fmt.Errorf("creating fixtures request: %w", err)
-// 	}
-
-// 	resp, err := s.httpClient.Do(req)
-// 	if err != nil {
-// 		return nil, fmt.Errorf("requesting fixtures: %w", err)
-// 	}
-// 	defer resp.Body.Close()
-
-// 	if resp.StatusCode != http.StatusOK {
-// 		body, _ := io.ReadAll(resp.Body)
-// 		return nil, fmt.Errorf("unexpected status %d: %s", resp.StatusCode, string(body))
-// 	}
-
-// 	// Decode response
-// 	var fixturesResp domain.FixturesResponse
-// 	if err := json.NewDecoder(resp.Body).Decode(&fixturesResp); err != nil {
-// 		return nil, fmt.Errorf("decoding fixtures response: %w", err)
-// 	}
-
-// 	return &fixturesResp, nil
-// }
-
 func (s *Service) FetchResults(ctx context.Context, params domain.ResultsRequest) (*domain.ResultsResponse, error) {
 	// Build base URL
 	url := fmt.Sprintf("http://eapi.enetpulse.com/event/results/?username=%s&token=%s",
@@ -1636,9 +1444,9 @@ func (s *Service) FetchResults(ctx context.Context, params domain.ResultsRequest
 	if params.TournamentTemplateFK != 0 {
 		url += fmt.Sprintf("&tournament_templateFK=%d", params.TournamentTemplateFK)
 	}
-	if params.TournamentStageFK != 0 {
-		url += fmt.Sprintf("&tournament_stageFK=%d", params.TournamentStageFK)
-	}
+	// if params.TournamentStageFK != 0 {
+	// 	url += fmt.Sprintf("&tournament_stageFK=%d", params.TournamentStageFK)
+	// }
 
 	// Optional filters
 	if params.LanguageTypeFK != 0 {
@@ -1774,7 +1582,7 @@ func (s *Service) FetchEventDetails(ctx context.Context, params domain.EventDeta
 
 func (s *Service) FetchEventList(ctx context.Context, params domain.EventListRequest) (*domain.EventListResponse, error) {
 	// You must provide either TournamentFK or TournamentStageFK
-	if params.TournamentFK == 0 && params.TournamentStageFK == 0 {
+	if params.TournamentFK == 0 {
 		return nil, fmt.Errorf("either TournamentFK or TournamentStageFK is required")
 	}
 
@@ -1786,9 +1594,9 @@ func (s *Service) FetchEventList(ctx context.Context, params domain.EventListReq
 	if params.TournamentFK != 0 {
 		url += fmt.Sprintf("&tournamentFK=%d", params.TournamentFK)
 	}
-	if params.TournamentStageFK != 0 {
-		url += fmt.Sprintf("&tournament_stageFK=%d", params.TournamentStageFK)
-	}
+	// if params.TournamentStageFK != 0 {
+	// 	url += fmt.Sprintf("&tournament_stageFK=%d", params.TournamentStageFK)
+	// }
 
 	// Optional parameters
 	if !params.IncludeEventProperties {
@@ -1859,9 +1667,9 @@ func (s *Service) FetchParticipantFixtures(ctx context.Context, params domain.Pa
 	if params.TournamentTemplateFK != 0 {
 		url += fmt.Sprintf("&tournament_templateFK=%d", params.TournamentTemplateFK)
 	}
-	if params.TournamentStageFK != 0 {
-		url += fmt.Sprintf("&tournament_stageFK=%d", params.TournamentStageFK)
-	}
+	// if params.TournamentStageFK != 0 {
+	// 	url += fmt.Sprintf("&tournament_stageFK=%d", params.TournamentStageFK)
+	// }
 	if params.Date != "" {
 		url += "&date=" + params.Date
 	}
diff --git a/internal/web_server/cron.go b/internal/web_server/cron.go
index 51f225f..f3aa93f 100644
--- a/internal/web_server/cron.go
+++ b/internal/web_server/cron.go
@@ -316,12 +316,12 @@ func StartEnetPulseCron(enetPulseSvc *enetpulse.Service, mongoLogger *zap.Logger
 				}
 
 				// 4️⃣ Tournament Stages
-				mongoLogger.Info("Began fetching and storing tournament stages cron task")
-				if err := enetPulseSvc.FetchAndStoreTournamentStages(ctx); err != nil {
-					mongoLogger.Error("Failed to fetch and store tournament stages", zap.Error(err))
-				} else {
-					mongoLogger.Info("✅ \n\nCompleted fetching and storing tournament stages\n\n")
-				}
+				// mongoLogger.Info("Began fetching and storing tournament stages cron task")
+				// if err := enetPulseSvc.FetchAndStoreTournamentStages(ctx); err != nil {
+				// 	mongoLogger.Error("Failed to fetch and store tournament stages", zap.Error(err))
+				// } else {
+				// 	mongoLogger.Info("✅ \n\nCompleted fetching and storing tournament stages\n\n")
+				// }
 
 				// // 5️⃣ Fixtures
 				mongoLogger.Info("Began fetching and storing fixtures cron task")
@@ -333,12 +333,12 @@ func StartEnetPulseCron(enetPulseSvc *enetpulse.Service, mongoLogger *zap.Logger
 				}
 
 				// 6️⃣ Results
-				mongoLogger.Info("Began fetching and storing results cron task")
-				if err := enetPulseSvc.FetchAndStoreResults(ctx); err != nil {
-					mongoLogger.Error("Failed to fetch and store results", zap.Error(err))
-				} else {
-					mongoLogger.Info("\n\n✅ Completed fetching and storing results\n\n")
-				}
+				// mongoLogger.Info("Began fetching and storing results cron task")
+				// if err := enetPulseSvc.FetchAndStoreResults(ctx); err != nil {
+				// 	mongoLogger.Error("Failed to fetch and store results", zap.Error(err))
+				// } else {
+				// 	mongoLogger.Info("\n\n✅ Completed fetching and storing results\n\n")
+				// }
 
 				// 7 Outcome Types
 				mongoLogger.Info("Began fetching and storing outcome_types cron task")