///|
/// Generated WebHook fixtures used by docs, examples, and regression tests.
/// The data intentionally spans multiple providers and event families.

///|
pub fn fixture_github_001() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-001",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"001\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-001"),
      ("x-hub-signature-256", "sha256=fixture-001"),
    ]),
  )
}

///|
pub fn fixture_github_002() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-002",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"002\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-002"),
      ("x-hub-signature-256", "sha256=fixture-002"),
    ]),
  )
}

///|
pub fn fixture_github_003() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-003",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"003\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-003"),
      ("x-hub-signature-256", "sha256=fixture-003"),
    ]),
  )
}

///|
pub fn fixture_github_004() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-004",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"004\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-004"),
      ("x-hub-signature-256", "sha256=fixture-004"),
    ]),
  )
}

///|
pub fn fixture_github_005() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-005",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"005\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-005"),
      ("x-hub-signature-256", "sha256=fixture-005"),
    ]),
  )
}

///|
pub fn fixture_github_006() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-006",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"006\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-006"),
      ("x-hub-signature-256", "sha256=fixture-006"),
    ]),
  )
}

///|
pub fn fixture_github_007() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-007",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"007\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-007"),
      ("x-hub-signature-256", "sha256=fixture-007"),
    ]),
  )
}

///|
pub fn fixture_github_008() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-008",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"008\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-008"),
      ("x-hub-signature-256", "sha256=fixture-008"),
    ]),
  )
}

///|
pub fn fixture_github_009() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-009",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"009\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-009"),
      ("x-hub-signature-256", "sha256=fixture-009"),
    ]),
  )
}

///|
pub fn fixture_github_010() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-010",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"010\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-010"),
      ("x-hub-signature-256", "sha256=fixture-010"),
    ]),
  )
}

///|
pub fn fixture_github_011() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-011",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"011\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-011"),
      ("x-hub-signature-256", "sha256=fixture-011"),
    ]),
  )
}

///|
pub fn fixture_github_012() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-012",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"012\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-012"),
      ("x-hub-signature-256", "sha256=fixture-012"),
    ]),
  )
}

///|
pub fn fixture_github_013() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-013",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"013\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-013"),
      ("x-hub-signature-256", "sha256=fixture-013"),
    ]),
  )
}

///|
pub fn fixture_github_014() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-014",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"014\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-014"),
      ("x-hub-signature-256", "sha256=fixture-014"),
    ]),
  )
}

///|
pub fn fixture_github_015() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-015",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"015\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-015"),
      ("x-hub-signature-256", "sha256=fixture-015"),
    ]),
  )
}

///|
pub fn fixture_github_016() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-016",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"016\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-016"),
      ("x-hub-signature-256", "sha256=fixture-016"),
    ]),
  )
}

///|
pub fn fixture_github_017() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-017",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"017\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-017"),
      ("x-hub-signature-256", "sha256=fixture-017"),
    ]),
  )
}

///|
pub fn fixture_github_018() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-018",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"018\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-018"),
      ("x-hub-signature-256", "sha256=fixture-018"),
    ]),
  )
}

///|
pub fn fixture_github_019() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-019",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"019\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-019"),
      ("x-hub-signature-256", "sha256=fixture-019"),
    ]),
  )
}

///|
pub fn fixture_github_020() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-020",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"020\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-020"),
      ("x-hub-signature-256", "sha256=fixture-020"),
    ]),
  )
}

///|
pub fn fixture_github_021() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-021",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"021\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-021"),
      ("x-hub-signature-256", "sha256=fixture-021"),
    ]),
  )
}

///|
pub fn fixture_github_022() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-022",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"022\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-022"),
      ("x-hub-signature-256", "sha256=fixture-022"),
    ]),
  )
}

///|
pub fn fixture_github_023() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-023",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"023\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-023"),
      ("x-hub-signature-256", "sha256=fixture-023"),
    ]),
  )
}

///|
pub fn fixture_github_024() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-024",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"024\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-024"),
      ("x-hub-signature-256", "sha256=fixture-024"),
    ]),
  )
}

///|
pub fn fixture_github_025() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-025",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"025\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-025"),
      ("x-hub-signature-256", "sha256=fixture-025"),
    ]),
  )
}

///|
pub fn fixture_github_026() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-026",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"026\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-026"),
      ("x-hub-signature-256", "sha256=fixture-026"),
    ]),
  )
}

///|
pub fn fixture_github_027() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-027",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"027\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-027"),
      ("x-hub-signature-256", "sha256=fixture-027"),
    ]),
  )
}

///|
pub fn fixture_github_028() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-028",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"028\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-028"),
      ("x-hub-signature-256", "sha256=fixture-028"),
    ]),
  )
}

///|
pub fn fixture_github_029() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-029",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"029\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-029"),
      ("x-hub-signature-256", "sha256=fixture-029"),
    ]),
  )
}

///|
pub fn fixture_github_030() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-030",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"030\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-030"),
      ("x-hub-signature-256", "sha256=fixture-030"),
    ]),
  )
}

///|
pub fn fixture_github_031() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-031",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"031\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-031"),
      ("x-hub-signature-256", "sha256=fixture-031"),
    ]),
  )
}

///|
pub fn fixture_github_032() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-032",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"032\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-032"),
      ("x-hub-signature-256", "sha256=fixture-032"),
    ]),
  )
}

///|
pub fn fixture_github_033() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-033",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"033\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-033"),
      ("x-hub-signature-256", "sha256=fixture-033"),
    ]),
  )
}

///|
pub fn fixture_github_034() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-034",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"034\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-034"),
      ("x-hub-signature-256", "sha256=fixture-034"),
    ]),
  )
}

///|
pub fn fixture_github_035() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-035",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"035\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-035"),
      ("x-hub-signature-256", "sha256=fixture-035"),
    ]),
  )
}

///|
pub fn fixture_github_036() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-036",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"036\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-036"),
      ("x-hub-signature-256", "sha256=fixture-036"),
    ]),
  )
}

///|
pub fn fixture_github_037() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-037",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"037\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-037"),
      ("x-hub-signature-256", "sha256=fixture-037"),
    ]),
  )
}

///|
pub fn fixture_github_038() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-038",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"038\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-038"),
      ("x-hub-signature-256", "sha256=fixture-038"),
    ]),
  )
}

///|
pub fn fixture_github_039() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-039",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"039\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-039"),
      ("x-hub-signature-256", "sha256=fixture-039"),
    ]),
  )
}

///|
pub fn fixture_github_040() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-040",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"040\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-040"),
      ("x-hub-signature-256", "sha256=fixture-040"),
    ]),
  )
}

///|
pub fn fixture_github_041() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-041",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"041\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-041"),
      ("x-hub-signature-256", "sha256=fixture-041"),
    ]),
  )
}

///|
pub fn fixture_github_042() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-042",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"042\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-042"),
      ("x-hub-signature-256", "sha256=fixture-042"),
    ]),
  )
}

///|
pub fn fixture_github_043() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-043",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"043\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-043"),
      ("x-hub-signature-256", "sha256=fixture-043"),
    ]),
  )
}

///|
pub fn fixture_github_044() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-044",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"044\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-044"),
      ("x-hub-signature-256", "sha256=fixture-044"),
    ]),
  )
}

///|
pub fn fixture_github_045() -> HookRequest {
  HookRequest(
    GitHub,
    "issues",
    "github-delivery-045",
    "{\"provider\":\"github\",\"event\":\"issues\",\"index\":\"045\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issues"),
      ("x-github-delivery", "github-delivery-045"),
      ("x-hub-signature-256", "sha256=fixture-045"),
    ]),
  )
}

///|
pub fn fixture_github_046() -> HookRequest {
  HookRequest(
    GitHub,
    "issue_comment",
    "github-delivery-046",
    "{\"provider\":\"github\",\"event\":\"issue_comment\",\"index\":\"046\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "issue_comment"),
      ("x-github-delivery", "github-delivery-046"),
      ("x-hub-signature-256", "sha256=fixture-046"),
    ]),
  )
}

///|
pub fn fixture_github_047() -> HookRequest {
  HookRequest(
    GitHub,
    "release",
    "github-delivery-047",
    "{\"provider\":\"github\",\"event\":\"release\",\"index\":\"047\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "release"),
      ("x-github-delivery", "github-delivery-047"),
      ("x-hub-signature-256", "sha256=fixture-047"),
    ]),
  )
}

///|
pub fn fixture_github_048() -> HookRequest {
  HookRequest(
    GitHub,
    "workflow_run",
    "github-delivery-048",
    "{\"provider\":\"github\",\"event\":\"workflow_run\",\"index\":\"048\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "workflow_run"),
      ("x-github-delivery", "github-delivery-048"),
      ("x-hub-signature-256", "sha256=fixture-048"),
    ]),
  )
}

///|
pub fn fixture_github_049() -> HookRequest {
  HookRequest(
    GitHub,
    "push",
    "github-delivery-049",
    "{\"provider\":\"github\",\"event\":\"push\",\"index\":\"049\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "push"),
      ("x-github-delivery", "github-delivery-049"),
      ("x-hub-signature-256", "sha256=fixture-049"),
    ]),
  )
}

///|
pub fn fixture_github_050() -> HookRequest {
  HookRequest(
    GitHub,
    "pull_request",
    "github-delivery-050",
    "{\"provider\":\"github\",\"event\":\"pull_request\",\"index\":\"050\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-github-event", "pull_request"),
      ("x-github-delivery", "github-delivery-050"),
      ("x-hub-signature-256", "sha256=fixture-050"),
    ]),
  )
}

///|
pub fn fixture_gitlab_001() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-001",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"001\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-001"),
      ("x-gitlab-token", "token-fixture-001"),
    ]),
  )
}

///|
pub fn fixture_gitlab_002() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-002",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"002\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-002"),
      ("x-gitlab-token", "token-fixture-002"),
    ]),
  )
}

///|
pub fn fixture_gitlab_003() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-003",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"003\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-003"),
      ("x-gitlab-token", "token-fixture-003"),
    ]),
  )
}

///|
pub fn fixture_gitlab_004() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-004",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"004\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-004"),
      ("x-gitlab-token", "token-fixture-004"),
    ]),
  )
}

///|
pub fn fixture_gitlab_005() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-005",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"005\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-005"),
      ("x-gitlab-token", "token-fixture-005"),
    ]),
  )
}

///|
pub fn fixture_gitlab_006() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-006",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"006\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-006"),
      ("x-gitlab-token", "token-fixture-006"),
    ]),
  )
}

///|
pub fn fixture_gitlab_007() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-007",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"007\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-007"),
      ("x-gitlab-token", "token-fixture-007"),
    ]),
  )
}

///|
pub fn fixture_gitlab_008() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-008",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"008\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-008"),
      ("x-gitlab-token", "token-fixture-008"),
    ]),
  )
}

///|
pub fn fixture_gitlab_009() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-009",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"009\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-009"),
      ("x-gitlab-token", "token-fixture-009"),
    ]),
  )
}

///|
pub fn fixture_gitlab_010() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-010",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"010\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-010"),
      ("x-gitlab-token", "token-fixture-010"),
    ]),
  )
}

///|
pub fn fixture_gitlab_011() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-011",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"011\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-011"),
      ("x-gitlab-token", "token-fixture-011"),
    ]),
  )
}

///|
pub fn fixture_gitlab_012() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-012",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"012\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-012"),
      ("x-gitlab-token", "token-fixture-012"),
    ]),
  )
}

///|
pub fn fixture_gitlab_013() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-013",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"013\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-013"),
      ("x-gitlab-token", "token-fixture-013"),
    ]),
  )
}

///|
pub fn fixture_gitlab_014() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-014",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"014\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-014"),
      ("x-gitlab-token", "token-fixture-014"),
    ]),
  )
}

///|
pub fn fixture_gitlab_015() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-015",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"015\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-015"),
      ("x-gitlab-token", "token-fixture-015"),
    ]),
  )
}

///|
pub fn fixture_gitlab_016() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-016",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"016\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-016"),
      ("x-gitlab-token", "token-fixture-016"),
    ]),
  )
}

///|
pub fn fixture_gitlab_017() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-017",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"017\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-017"),
      ("x-gitlab-token", "token-fixture-017"),
    ]),
  )
}

///|
pub fn fixture_gitlab_018() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-018",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"018\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-018"),
      ("x-gitlab-token", "token-fixture-018"),
    ]),
  )
}

///|
pub fn fixture_gitlab_019() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-019",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"019\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-019"),
      ("x-gitlab-token", "token-fixture-019"),
    ]),
  )
}

///|
pub fn fixture_gitlab_020() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-020",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"020\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-020"),
      ("x-gitlab-token", "token-fixture-020"),
    ]),
  )
}

///|
pub fn fixture_gitlab_021() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-021",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"021\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-021"),
      ("x-gitlab-token", "token-fixture-021"),
    ]),
  )
}

///|
pub fn fixture_gitlab_022() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-022",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"022\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-022"),
      ("x-gitlab-token", "token-fixture-022"),
    ]),
  )
}

///|
pub fn fixture_gitlab_023() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-023",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"023\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-023"),
      ("x-gitlab-token", "token-fixture-023"),
    ]),
  )
}

///|
pub fn fixture_gitlab_024() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-024",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"024\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-024"),
      ("x-gitlab-token", "token-fixture-024"),
    ]),
  )
}

///|
pub fn fixture_gitlab_025() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-025",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"025\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-025"),
      ("x-gitlab-token", "token-fixture-025"),
    ]),
  )
}

///|
pub fn fixture_gitlab_026() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-026",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"026\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-026"),
      ("x-gitlab-token", "token-fixture-026"),
    ]),
  )
}

///|
pub fn fixture_gitlab_027() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-027",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"027\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-027"),
      ("x-gitlab-token", "token-fixture-027"),
    ]),
  )
}

///|
pub fn fixture_gitlab_028() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-028",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"028\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-028"),
      ("x-gitlab-token", "token-fixture-028"),
    ]),
  )
}

///|
pub fn fixture_gitlab_029() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-029",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"029\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-029"),
      ("x-gitlab-token", "token-fixture-029"),
    ]),
  )
}

///|
pub fn fixture_gitlab_030() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-030",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"030\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-030"),
      ("x-gitlab-token", "token-fixture-030"),
    ]),
  )
}

///|
pub fn fixture_gitlab_031() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-031",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"031\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-031"),
      ("x-gitlab-token", "token-fixture-031"),
    ]),
  )
}

///|
pub fn fixture_gitlab_032() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-032",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"032\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-032"),
      ("x-gitlab-token", "token-fixture-032"),
    ]),
  )
}

///|
pub fn fixture_gitlab_033() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-033",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"033\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-033"),
      ("x-gitlab-token", "token-fixture-033"),
    ]),
  )
}

///|
pub fn fixture_gitlab_034() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-034",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"034\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-034"),
      ("x-gitlab-token", "token-fixture-034"),
    ]),
  )
}

///|
pub fn fixture_gitlab_035() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-035",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"035\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-035"),
      ("x-gitlab-token", "token-fixture-035"),
    ]),
  )
}

///|
pub fn fixture_gitlab_036() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-036",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"036\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-036"),
      ("x-gitlab-token", "token-fixture-036"),
    ]),
  )
}

///|
pub fn fixture_gitlab_037() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-037",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"037\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-037"),
      ("x-gitlab-token", "token-fixture-037"),
    ]),
  )
}

///|
pub fn fixture_gitlab_038() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-038",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"038\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-038"),
      ("x-gitlab-token", "token-fixture-038"),
    ]),
  )
}

///|
pub fn fixture_gitlab_039() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-039",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"039\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-039"),
      ("x-gitlab-token", "token-fixture-039"),
    ]),
  )
}

///|
pub fn fixture_gitlab_040() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-040",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"040\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-040"),
      ("x-gitlab-token", "token-fixture-040"),
    ]),
  )
}

///|
pub fn fixture_gitlab_041() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-041",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"041\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-041"),
      ("x-gitlab-token", "token-fixture-041"),
    ]),
  )
}

///|
pub fn fixture_gitlab_042() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-042",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"042\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-042"),
      ("x-gitlab-token", "token-fixture-042"),
    ]),
  )
}

///|
pub fn fixture_gitlab_043() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-043",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"043\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-043"),
      ("x-gitlab-token", "token-fixture-043"),
    ]),
  )
}

///|
pub fn fixture_gitlab_044() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-044",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"044\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-044"),
      ("x-gitlab-token", "token-fixture-044"),
    ]),
  )
}

///|
pub fn fixture_gitlab_045() -> HookRequest {
  HookRequest(
    GitLab,
    "issue",
    "gitlab-delivery-045",
    "{\"provider\":\"gitlab\",\"event\":\"issue\",\"index\":\"045\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "issue"),
      ("x-gitlab-delivery", "gitlab-delivery-045"),
      ("x-gitlab-token", "token-fixture-045"),
    ]),
  )
}

///|
pub fn fixture_gitlab_046() -> HookRequest {
  HookRequest(
    GitLab,
    "note",
    "gitlab-delivery-046",
    "{\"provider\":\"gitlab\",\"event\":\"note\",\"index\":\"046\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "note"),
      ("x-gitlab-delivery", "gitlab-delivery-046"),
      ("x-gitlab-token", "token-fixture-046"),
    ]),
  )
}

///|
pub fn fixture_gitlab_047() -> HookRequest {
  HookRequest(
    GitLab,
    "pipeline",
    "gitlab-delivery-047",
    "{\"provider\":\"gitlab\",\"event\":\"pipeline\",\"index\":\"047\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "pipeline"),
      ("x-gitlab-delivery", "gitlab-delivery-047"),
      ("x-gitlab-token", "token-fixture-047"),
    ]),
  )
}

///|
pub fn fixture_gitlab_048() -> HookRequest {
  HookRequest(
    GitLab,
    "job",
    "gitlab-delivery-048",
    "{\"provider\":\"gitlab\",\"event\":\"job\",\"index\":\"048\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "job"),
      ("x-gitlab-delivery", "gitlab-delivery-048"),
      ("x-gitlab-token", "token-fixture-048"),
    ]),
  )
}

///|
pub fn fixture_gitlab_049() -> HookRequest {
  HookRequest(
    GitLab,
    "push",
    "gitlab-delivery-049",
    "{\"provider\":\"gitlab\",\"event\":\"push\",\"index\":\"049\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "push"),
      ("x-gitlab-delivery", "gitlab-delivery-049"),
      ("x-gitlab-token", "token-fixture-049"),
    ]),
  )
}

///|
pub fn fixture_gitlab_050() -> HookRequest {
  HookRequest(
    GitLab,
    "merge_request",
    "gitlab-delivery-050",
    "{\"provider\":\"gitlab\",\"event\":\"merge_request\",\"index\":\"050\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitlab-event", "merge_request"),
      ("x-gitlab-delivery", "gitlab-delivery-050"),
      ("x-gitlab-token", "token-fixture-050"),
    ]),
  )
}

///|
pub fn fixture_gitee_001() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-001",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"001\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-001"),
      ("x-gitee-token", "token-fixture-001"),
    ]),
  )
}

///|
pub fn fixture_gitee_002() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-002",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"002\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-002"),
      ("x-gitee-token", "token-fixture-002"),
    ]),
  )
}

///|
pub fn fixture_gitee_003() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-003",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"003\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-003"),
      ("x-gitee-token", "token-fixture-003"),
    ]),
  )
}

///|
pub fn fixture_gitee_004() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-004",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"004\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-004"),
      ("x-gitee-token", "token-fixture-004"),
    ]),
  )
}

///|
pub fn fixture_gitee_005() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-005",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"005\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-005"),
      ("x-gitee-token", "token-fixture-005"),
    ]),
  )
}

///|
pub fn fixture_gitee_006() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-006",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"006\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-006"),
      ("x-gitee-token", "token-fixture-006"),
    ]),
  )
}

///|
pub fn fixture_gitee_007() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-007",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"007\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-007"),
      ("x-gitee-token", "token-fixture-007"),
    ]),
  )
}

///|
pub fn fixture_gitee_008() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-008",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"008\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-008"),
      ("x-gitee-token", "token-fixture-008"),
    ]),
  )
}

///|
pub fn fixture_gitee_009() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-009",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"009\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-009"),
      ("x-gitee-token", "token-fixture-009"),
    ]),
  )
}

///|
pub fn fixture_gitee_010() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-010",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"010\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-010"),
      ("x-gitee-token", "token-fixture-010"),
    ]),
  )
}

///|
pub fn fixture_gitee_011() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-011",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"011\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-011"),
      ("x-gitee-token", "token-fixture-011"),
    ]),
  )
}

///|
pub fn fixture_gitee_012() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-012",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"012\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-012"),
      ("x-gitee-token", "token-fixture-012"),
    ]),
  )
}

///|
pub fn fixture_gitee_013() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-013",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"013\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-013"),
      ("x-gitee-token", "token-fixture-013"),
    ]),
  )
}

///|
pub fn fixture_gitee_014() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-014",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"014\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-014"),
      ("x-gitee-token", "token-fixture-014"),
    ]),
  )
}

///|
pub fn fixture_gitee_015() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-015",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"015\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-015"),
      ("x-gitee-token", "token-fixture-015"),
    ]),
  )
}

///|
pub fn fixture_gitee_016() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-016",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"016\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-016"),
      ("x-gitee-token", "token-fixture-016"),
    ]),
  )
}

///|
pub fn fixture_gitee_017() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-017",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"017\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-017"),
      ("x-gitee-token", "token-fixture-017"),
    ]),
  )
}

///|
pub fn fixture_gitee_018() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-018",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"018\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-018"),
      ("x-gitee-token", "token-fixture-018"),
    ]),
  )
}

///|
pub fn fixture_gitee_019() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-019",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"019\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-019"),
      ("x-gitee-token", "token-fixture-019"),
    ]),
  )
}

///|
pub fn fixture_gitee_020() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-020",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"020\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-020"),
      ("x-gitee-token", "token-fixture-020"),
    ]),
  )
}

///|
pub fn fixture_gitee_021() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-021",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"021\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-021"),
      ("x-gitee-token", "token-fixture-021"),
    ]),
  )
}

///|
pub fn fixture_gitee_022() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-022",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"022\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-022"),
      ("x-gitee-token", "token-fixture-022"),
    ]),
  )
}

///|
pub fn fixture_gitee_023() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-023",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"023\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-023"),
      ("x-gitee-token", "token-fixture-023"),
    ]),
  )
}

///|
pub fn fixture_gitee_024() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-024",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"024\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-024"),
      ("x-gitee-token", "token-fixture-024"),
    ]),
  )
}

///|
pub fn fixture_gitee_025() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-025",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"025\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-025"),
      ("x-gitee-token", "token-fixture-025"),
    ]),
  )
}

///|
pub fn fixture_gitee_026() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-026",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"026\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-026"),
      ("x-gitee-token", "token-fixture-026"),
    ]),
  )
}

///|
pub fn fixture_gitee_027() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-027",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"027\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-027"),
      ("x-gitee-token", "token-fixture-027"),
    ]),
  )
}

///|
pub fn fixture_gitee_028() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-028",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"028\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-028"),
      ("x-gitee-token", "token-fixture-028"),
    ]),
  )
}

///|
pub fn fixture_gitee_029() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-029",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"029\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-029"),
      ("x-gitee-token", "token-fixture-029"),
    ]),
  )
}

///|
pub fn fixture_gitee_030() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-030",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"030\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-030"),
      ("x-gitee-token", "token-fixture-030"),
    ]),
  )
}

///|
pub fn fixture_gitee_031() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-031",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"031\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-031"),
      ("x-gitee-token", "token-fixture-031"),
    ]),
  )
}

///|
pub fn fixture_gitee_032() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-032",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"032\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-032"),
      ("x-gitee-token", "token-fixture-032"),
    ]),
  )
}

///|
pub fn fixture_gitee_033() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-033",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"033\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-033"),
      ("x-gitee-token", "token-fixture-033"),
    ]),
  )
}

///|
pub fn fixture_gitee_034() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-034",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"034\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-034"),
      ("x-gitee-token", "token-fixture-034"),
    ]),
  )
}

///|
pub fn fixture_gitee_035() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-035",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"035\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-035"),
      ("x-gitee-token", "token-fixture-035"),
    ]),
  )
}

///|
pub fn fixture_gitee_036() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-036",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"036\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-036"),
      ("x-gitee-token", "token-fixture-036"),
    ]),
  )
}

///|
pub fn fixture_gitee_037() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-037",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"037\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-037"),
      ("x-gitee-token", "token-fixture-037"),
    ]),
  )
}

///|
pub fn fixture_gitee_038() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-038",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"038\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-038"),
      ("x-gitee-token", "token-fixture-038"),
    ]),
  )
}

///|
pub fn fixture_gitee_039() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-039",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"039\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-039"),
      ("x-gitee-token", "token-fixture-039"),
    ]),
  )
}

///|
pub fn fixture_gitee_040() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-040",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"040\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-040"),
      ("x-gitee-token", "token-fixture-040"),
    ]),
  )
}

///|
pub fn fixture_gitee_041() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-041",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"041\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-041"),
      ("x-gitee-token", "token-fixture-041"),
    ]),
  )
}

///|
pub fn fixture_gitee_042() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-042",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"042\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-042"),
      ("x-gitee-token", "token-fixture-042"),
    ]),
  )
}

///|
pub fn fixture_gitee_043() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-043",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"043\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-043"),
      ("x-gitee-token", "token-fixture-043"),
    ]),
  )
}

///|
pub fn fixture_gitee_044() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-044",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"044\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-044"),
      ("x-gitee-token", "token-fixture-044"),
    ]),
  )
}

///|
pub fn fixture_gitee_045() -> HookRequest {
  HookRequest(
    Gitee,
    "issue",
    "gitee-delivery-045",
    "{\"provider\":\"gitee\",\"event\":\"issue\",\"index\":\"045\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "issue"),
      ("x-gitee-delivery", "gitee-delivery-045"),
      ("x-gitee-token", "token-fixture-045"),
    ]),
  )
}

///|
pub fn fixture_gitee_046() -> HookRequest {
  HookRequest(
    Gitee,
    "note",
    "gitee-delivery-046",
    "{\"provider\":\"gitee\",\"event\":\"note\",\"index\":\"046\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "note"),
      ("x-gitee-delivery", "gitee-delivery-046"),
      ("x-gitee-token", "token-fixture-046"),
    ]),
  )
}

///|
pub fn fixture_gitee_047() -> HookRequest {
  HookRequest(
    Gitee,
    "release",
    "gitee-delivery-047",
    "{\"provider\":\"gitee\",\"event\":\"release\",\"index\":\"047\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "release"),
      ("x-gitee-delivery", "gitee-delivery-047"),
      ("x-gitee-token", "token-fixture-047"),
    ]),
  )
}

///|
pub fn fixture_gitee_048() -> HookRequest {
  HookRequest(
    Gitee,
    "tag_push",
    "gitee-delivery-048",
    "{\"provider\":\"gitee\",\"event\":\"tag_push\",\"index\":\"048\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "tag_push"),
      ("x-gitee-delivery", "gitee-delivery-048"),
      ("x-gitee-token", "token-fixture-048"),
    ]),
  )
}

///|
pub fn fixture_gitee_049() -> HookRequest {
  HookRequest(
    Gitee,
    "push",
    "gitee-delivery-049",
    "{\"provider\":\"gitee\",\"event\":\"push\",\"index\":\"049\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "push"),
      ("x-gitee-delivery", "gitee-delivery-049"),
      ("x-gitee-token", "token-fixture-049"),
    ]),
  )
}

///|
pub fn fixture_gitee_050() -> HookRequest {
  HookRequest(
    Gitee,
    "pull_request",
    "gitee-delivery-050",
    "{\"provider\":\"gitee\",\"event\":\"pull_request\",\"index\":\"050\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-gitee-event", "pull_request"),
      ("x-gitee-delivery", "gitee-delivery-050"),
      ("x-gitee-token", "token-fixture-050"),
    ]),
  )
}

///|
pub fn fixture_feishu_001() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-001",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"001\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-001"),
      ("x-lark-signature", "v1,fixture-001"),
    ]),
  )
}

///|
pub fn fixture_feishu_002() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-002",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"002\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-002"),
      ("x-lark-signature", "v1,fixture-002"),
    ]),
  )
}

///|
pub fn fixture_feishu_003() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-003",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"003\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-003"),
      ("x-lark-signature", "v1,fixture-003"),
    ]),
  )
}

///|
pub fn fixture_feishu_004() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-004",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"004\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-004"),
      ("x-lark-signature", "v1,fixture-004"),
    ]),
  )
}

///|
pub fn fixture_feishu_005() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-005",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"005\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-005"),
      ("x-lark-signature", "v1,fixture-005"),
    ]),
  )
}

///|
pub fn fixture_feishu_006() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-006",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"006\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-006"),
      ("x-lark-signature", "v1,fixture-006"),
    ]),
  )
}

///|
pub fn fixture_feishu_007() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-007",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"007\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-007"),
      ("x-lark-signature", "v1,fixture-007"),
    ]),
  )
}

///|
pub fn fixture_feishu_008() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-008",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"008\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-008"),
      ("x-lark-signature", "v1,fixture-008"),
    ]),
  )
}

///|
pub fn fixture_feishu_009() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-009",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"009\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-009"),
      ("x-lark-signature", "v1,fixture-009"),
    ]),
  )
}

///|
pub fn fixture_feishu_010() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-010",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"010\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-010"),
      ("x-lark-signature", "v1,fixture-010"),
    ]),
  )
}

///|
pub fn fixture_feishu_011() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-011",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"011\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-011"),
      ("x-lark-signature", "v1,fixture-011"),
    ]),
  )
}

///|
pub fn fixture_feishu_012() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-012",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"012\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-012"),
      ("x-lark-signature", "v1,fixture-012"),
    ]),
  )
}

///|
pub fn fixture_feishu_013() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-013",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"013\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-013"),
      ("x-lark-signature", "v1,fixture-013"),
    ]),
  )
}

///|
pub fn fixture_feishu_014() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-014",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"014\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-014"),
      ("x-lark-signature", "v1,fixture-014"),
    ]),
  )
}

///|
pub fn fixture_feishu_015() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-015",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"015\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-015"),
      ("x-lark-signature", "v1,fixture-015"),
    ]),
  )
}

///|
pub fn fixture_feishu_016() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-016",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"016\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-016"),
      ("x-lark-signature", "v1,fixture-016"),
    ]),
  )
}

///|
pub fn fixture_feishu_017() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-017",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"017\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-017"),
      ("x-lark-signature", "v1,fixture-017"),
    ]),
  )
}

///|
pub fn fixture_feishu_018() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-018",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"018\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-018"),
      ("x-lark-signature", "v1,fixture-018"),
    ]),
  )
}

///|
pub fn fixture_feishu_019() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-019",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"019\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-019"),
      ("x-lark-signature", "v1,fixture-019"),
    ]),
  )
}

///|
pub fn fixture_feishu_020() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-020",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"020\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-020"),
      ("x-lark-signature", "v1,fixture-020"),
    ]),
  )
}

///|
pub fn fixture_feishu_021() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-021",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"021\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-021"),
      ("x-lark-signature", "v1,fixture-021"),
    ]),
  )
}

///|
pub fn fixture_feishu_022() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-022",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"022\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-022"),
      ("x-lark-signature", "v1,fixture-022"),
    ]),
  )
}

///|
pub fn fixture_feishu_023() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-023",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"023\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-023"),
      ("x-lark-signature", "v1,fixture-023"),
    ]),
  )
}

///|
pub fn fixture_feishu_024() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-024",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"024\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-024"),
      ("x-lark-signature", "v1,fixture-024"),
    ]),
  )
}

///|
pub fn fixture_feishu_025() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-025",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"025\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-025"),
      ("x-lark-signature", "v1,fixture-025"),
    ]),
  )
}

///|
pub fn fixture_feishu_026() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-026",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"026\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-026"),
      ("x-lark-signature", "v1,fixture-026"),
    ]),
  )
}

///|
pub fn fixture_feishu_027() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-027",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"027\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-027"),
      ("x-lark-signature", "v1,fixture-027"),
    ]),
  )
}

///|
pub fn fixture_feishu_028() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-028",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"028\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-028"),
      ("x-lark-signature", "v1,fixture-028"),
    ]),
  )
}

///|
pub fn fixture_feishu_029() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-029",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"029\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-029"),
      ("x-lark-signature", "v1,fixture-029"),
    ]),
  )
}

///|
pub fn fixture_feishu_030() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-030",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"030\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-030"),
      ("x-lark-signature", "v1,fixture-030"),
    ]),
  )
}

///|
pub fn fixture_feishu_031() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-031",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"031\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-031"),
      ("x-lark-signature", "v1,fixture-031"),
    ]),
  )
}

///|
pub fn fixture_feishu_032() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-032",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"032\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-032"),
      ("x-lark-signature", "v1,fixture-032"),
    ]),
  )
}

///|
pub fn fixture_feishu_033() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-033",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"033\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-033"),
      ("x-lark-signature", "v1,fixture-033"),
    ]),
  )
}

///|
pub fn fixture_feishu_034() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-034",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"034\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-034"),
      ("x-lark-signature", "v1,fixture-034"),
    ]),
  )
}

///|
pub fn fixture_feishu_035() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-035",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"035\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-035"),
      ("x-lark-signature", "v1,fixture-035"),
    ]),
  )
}

///|
pub fn fixture_feishu_036() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-036",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"036\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-036"),
      ("x-lark-signature", "v1,fixture-036"),
    ]),
  )
}

///|
pub fn fixture_feishu_037() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-037",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"037\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-037"),
      ("x-lark-signature", "v1,fixture-037"),
    ]),
  )
}

///|
pub fn fixture_feishu_038() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-038",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"038\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-038"),
      ("x-lark-signature", "v1,fixture-038"),
    ]),
  )
}

///|
pub fn fixture_feishu_039() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-039",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"039\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-039"),
      ("x-lark-signature", "v1,fixture-039"),
    ]),
  )
}

///|
pub fn fixture_feishu_040() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-040",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"040\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-040"),
      ("x-lark-signature", "v1,fixture-040"),
    ]),
  )
}

///|
pub fn fixture_feishu_041() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-041",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"041\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-041"),
      ("x-lark-signature", "v1,fixture-041"),
    ]),
  )
}

///|
pub fn fixture_feishu_042() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-042",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"042\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-042"),
      ("x-lark-signature", "v1,fixture-042"),
    ]),
  )
}

///|
pub fn fixture_feishu_043() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-043",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"043\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-043"),
      ("x-lark-signature", "v1,fixture-043"),
    ]),
  )
}

///|
pub fn fixture_feishu_044() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-044",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"044\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-044"),
      ("x-lark-signature", "v1,fixture-044"),
    ]),
  )
}

///|
pub fn fixture_feishu_045() -> HookRequest {
  HookRequest(
    Feishu,
    "approval",
    "feishu-delivery-045",
    "{\"provider\":\"feishu\",\"event\":\"approval\",\"index\":\"045\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "approval"),
      ("x-lark-request-id", "feishu-delivery-045"),
      ("x-lark-signature", "v1,fixture-045"),
    ]),
  )
}

///|
pub fn fixture_feishu_046() -> HookRequest {
  HookRequest(
    Feishu,
    "calendar",
    "feishu-delivery-046",
    "{\"provider\":\"feishu\",\"event\":\"calendar\",\"index\":\"046\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "calendar"),
      ("x-lark-request-id", "feishu-delivery-046"),
      ("x-lark-signature", "v1,fixture-046"),
    ]),
  )
}

///|
pub fn fixture_feishu_047() -> HookRequest {
  HookRequest(
    Feishu,
    "drive",
    "feishu-delivery-047",
    "{\"provider\":\"feishu\",\"event\":\"drive\",\"index\":\"047\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "drive"),
      ("x-lark-request-id", "feishu-delivery-047"),
      ("x-lark-signature", "v1,fixture-047"),
    ]),
  )
}

///|
pub fn fixture_feishu_048() -> HookRequest {
  HookRequest(
    Feishu,
    "bot",
    "feishu-delivery-048",
    "{\"provider\":\"feishu\",\"event\":\"bot\",\"index\":\"048\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "bot"),
      ("x-lark-request-id", "feishu-delivery-048"),
      ("x-lark-signature", "v1,fixture-048"),
    ]),
  )
}

///|
pub fn fixture_feishu_049() -> HookRequest {
  HookRequest(
    Feishu,
    "message",
    "feishu-delivery-049",
    "{\"provider\":\"feishu\",\"event\":\"message\",\"index\":\"049\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "message"),
      ("x-lark-request-id", "feishu-delivery-049"),
      ("x-lark-signature", "v1,fixture-049"),
    ]),
  )
}

///|
pub fn fixture_feishu_050() -> HookRequest {
  HookRequest(
    Feishu,
    "interactive",
    "feishu-delivery-050",
    "{\"provider\":\"feishu\",\"event\":\"interactive\",\"index\":\"050\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-lark-request-event", "interactive"),
      ("x-lark-request-id", "feishu-delivery-050"),
      ("x-lark-signature", "v1,fixture-050"),
    ]),
  )
}

///|
pub fn fixture_wecom_001() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-001",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"001\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-001"),
      ("x-wecom-signature", "v1=fixture-001"),
    ]),
  )
}

///|
pub fn fixture_wecom_002() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-002",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"002\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-002"),
      ("x-wecom-signature", "v1=fixture-002"),
    ]),
  )
}

///|
pub fn fixture_wecom_003() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-003",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"003\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-003"),
      ("x-wecom-signature", "v1=fixture-003"),
    ]),
  )
}

///|
pub fn fixture_wecom_004() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-004",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"004\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-004"),
      ("x-wecom-signature", "v1=fixture-004"),
    ]),
  )
}

///|
pub fn fixture_wecom_005() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-005",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"005\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-005"),
      ("x-wecom-signature", "v1=fixture-005"),
    ]),
  )
}

///|
pub fn fixture_wecom_006() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-006",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"006\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-006"),
      ("x-wecom-signature", "v1=fixture-006"),
    ]),
  )
}

///|
pub fn fixture_wecom_007() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-007",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"007\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-007"),
      ("x-wecom-signature", "v1=fixture-007"),
    ]),
  )
}

///|
pub fn fixture_wecom_008() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-008",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"008\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-008"),
      ("x-wecom-signature", "v1=fixture-008"),
    ]),
  )
}

///|
pub fn fixture_wecom_009() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-009",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"009\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-009"),
      ("x-wecom-signature", "v1=fixture-009"),
    ]),
  )
}

///|
pub fn fixture_wecom_010() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-010",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"010\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-010"),
      ("x-wecom-signature", "v1=fixture-010"),
    ]),
  )
}

///|
pub fn fixture_wecom_011() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-011",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"011\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-011"),
      ("x-wecom-signature", "v1=fixture-011"),
    ]),
  )
}

///|
pub fn fixture_wecom_012() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-012",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"012\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-012"),
      ("x-wecom-signature", "v1=fixture-012"),
    ]),
  )
}

///|
pub fn fixture_wecom_013() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-013",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"013\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-013"),
      ("x-wecom-signature", "v1=fixture-013"),
    ]),
  )
}

///|
pub fn fixture_wecom_014() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-014",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"014\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-014"),
      ("x-wecom-signature", "v1=fixture-014"),
    ]),
  )
}

///|
pub fn fixture_wecom_015() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-015",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"015\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-015"),
      ("x-wecom-signature", "v1=fixture-015"),
    ]),
  )
}

///|
pub fn fixture_wecom_016() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-016",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"016\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-016"),
      ("x-wecom-signature", "v1=fixture-016"),
    ]),
  )
}

///|
pub fn fixture_wecom_017() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-017",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"017\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-017"),
      ("x-wecom-signature", "v1=fixture-017"),
    ]),
  )
}

///|
pub fn fixture_wecom_018() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-018",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"018\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-018"),
      ("x-wecom-signature", "v1=fixture-018"),
    ]),
  )
}

///|
pub fn fixture_wecom_019() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-019",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"019\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-019"),
      ("x-wecom-signature", "v1=fixture-019"),
    ]),
  )
}

///|
pub fn fixture_wecom_020() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-020",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"020\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-020"),
      ("x-wecom-signature", "v1=fixture-020"),
    ]),
  )
}

///|
pub fn fixture_wecom_021() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-021",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"021\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-021"),
      ("x-wecom-signature", "v1=fixture-021"),
    ]),
  )
}

///|
pub fn fixture_wecom_022() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-022",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"022\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-022"),
      ("x-wecom-signature", "v1=fixture-022"),
    ]),
  )
}

///|
pub fn fixture_wecom_023() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-023",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"023\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-023"),
      ("x-wecom-signature", "v1=fixture-023"),
    ]),
  )
}

///|
pub fn fixture_wecom_024() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-024",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"024\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-024"),
      ("x-wecom-signature", "v1=fixture-024"),
    ]),
  )
}

///|
pub fn fixture_wecom_025() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-025",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"025\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-025"),
      ("x-wecom-signature", "v1=fixture-025"),
    ]),
  )
}

///|
pub fn fixture_wecom_026() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-026",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"026\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-026"),
      ("x-wecom-signature", "v1=fixture-026"),
    ]),
  )
}

///|
pub fn fixture_wecom_027() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-027",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"027\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-027"),
      ("x-wecom-signature", "v1=fixture-027"),
    ]),
  )
}

///|
pub fn fixture_wecom_028() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-028",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"028\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-028"),
      ("x-wecom-signature", "v1=fixture-028"),
    ]),
  )
}

///|
pub fn fixture_wecom_029() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-029",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"029\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-029"),
      ("x-wecom-signature", "v1=fixture-029"),
    ]),
  )
}

///|
pub fn fixture_wecom_030() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-030",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"030\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-030"),
      ("x-wecom-signature", "v1=fixture-030"),
    ]),
  )
}

///|
pub fn fixture_wecom_031() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-031",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"031\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-031"),
      ("x-wecom-signature", "v1=fixture-031"),
    ]),
  )
}

///|
pub fn fixture_wecom_032() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-032",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"032\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-032"),
      ("x-wecom-signature", "v1=fixture-032"),
    ]),
  )
}

///|
pub fn fixture_wecom_033() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-033",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"033\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-033"),
      ("x-wecom-signature", "v1=fixture-033"),
    ]),
  )
}

///|
pub fn fixture_wecom_034() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-034",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"034\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-034"),
      ("x-wecom-signature", "v1=fixture-034"),
    ]),
  )
}

///|
pub fn fixture_wecom_035() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-035",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"035\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-035"),
      ("x-wecom-signature", "v1=fixture-035"),
    ]),
  )
}

///|
pub fn fixture_wecom_036() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-036",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"036\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-036"),
      ("x-wecom-signature", "v1=fixture-036"),
    ]),
  )
}

///|
pub fn fixture_wecom_037() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-037",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"037\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-037"),
      ("x-wecom-signature", "v1=fixture-037"),
    ]),
  )
}

///|
pub fn fixture_wecom_038() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-038",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"038\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-038"),
      ("x-wecom-signature", "v1=fixture-038"),
    ]),
  )
}

///|
pub fn fixture_wecom_039() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-039",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"039\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-039"),
      ("x-wecom-signature", "v1=fixture-039"),
    ]),
  )
}

///|
pub fn fixture_wecom_040() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-040",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"040\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-040"),
      ("x-wecom-signature", "v1=fixture-040"),
    ]),
  )
}

///|
pub fn fixture_wecom_041() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-041",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"041\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-041"),
      ("x-wecom-signature", "v1=fixture-041"),
    ]),
  )
}

///|
pub fn fixture_wecom_042() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-042",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"042\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-042"),
      ("x-wecom-signature", "v1=fixture-042"),
    ]),
  )
}

///|
pub fn fixture_wecom_043() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-043",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"043\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-043"),
      ("x-wecom-signature", "v1=fixture-043"),
    ]),
  )
}

///|
pub fn fixture_wecom_044() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-044",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"044\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-044"),
      ("x-wecom-signature", "v1=fixture-044"),
    ]),
  )
}

///|
pub fn fixture_wecom_045() -> HookRequest {
  HookRequest(
    WeCom,
    "external_contact",
    "wecom-delivery-045",
    "{\"provider\":\"wecom\",\"event\":\"external_contact\",\"index\":\"045\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "external_contact"),
      ("x-wecom-msgid", "wecom-delivery-045"),
      ("x-wecom-signature", "v1=fixture-045"),
    ]),
  )
}

///|
pub fn fixture_wecom_046() -> HookRequest {
  HookRequest(
    WeCom,
    "kf_message",
    "wecom-delivery-046",
    "{\"provider\":\"wecom\",\"event\":\"kf_message\",\"index\":\"046\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "kf_message"),
      ("x-wecom-msgid", "wecom-delivery-046"),
      ("x-wecom-signature", "v1=fixture-046"),
    ]),
  )
}

///|
pub fn fixture_wecom_047() -> HookRequest {
  HookRequest(
    WeCom,
    "menu_click",
    "wecom-delivery-047",
    "{\"provider\":\"wecom\",\"event\":\"menu_click\",\"index\":\"047\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "menu_click"),
      ("x-wecom-msgid", "wecom-delivery-047"),
      ("x-wecom-signature", "v1=fixture-047"),
    ]),
  )
}

///|
pub fn fixture_wecom_048() -> HookRequest {
  HookRequest(
    WeCom,
    "location",
    "wecom-delivery-048",
    "{\"provider\":\"wecom\",\"event\":\"location\",\"index\":\"048\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "location"),
      ("x-wecom-msgid", "wecom-delivery-048"),
      ("x-wecom-signature", "v1=fixture-048"),
    ]),
  )
}

///|
pub fn fixture_wecom_049() -> HookRequest {
  HookRequest(
    WeCom,
    "message",
    "wecom-delivery-049",
    "{\"provider\":\"wecom\",\"event\":\"message\",\"index\":\"049\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "message"),
      ("x-wecom-msgid", "wecom-delivery-049"),
      ("x-wecom-signature", "v1=fixture-049"),
    ]),
  )
}

///|
pub fn fixture_wecom_050() -> HookRequest {
  HookRequest(
    WeCom,
    "approval",
    "wecom-delivery-050",
    "{\"provider\":\"wecom\",\"event\":\"approval\",\"index\":\"050\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("x-wecom-event", "approval"),
      ("x-wecom-msgid", "wecom-delivery-050"),
      ("x-wecom-signature", "v1=fixture-050"),
    ]),
  )
}

///|
pub fn fixture_stripe_001() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-001",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"001\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-001"),
      ("stripe-signature", "t=fixture,v1=fixture-001"),
    ]),
  )
}

///|
pub fn fixture_stripe_002() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-002",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"002\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-002"),
      ("stripe-signature", "t=fixture,v1=fixture-002"),
    ]),
  )
}

///|
pub fn fixture_stripe_003() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-003",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"003\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-003"),
      ("stripe-signature", "t=fixture,v1=fixture-003"),
    ]),
  )
}

///|
pub fn fixture_stripe_004() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-004",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"004\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-004"),
      ("stripe-signature", "t=fixture,v1=fixture-004"),
    ]),
  )
}

///|
pub fn fixture_stripe_005() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-005",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"005\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-005"),
      ("stripe-signature", "t=fixture,v1=fixture-005"),
    ]),
  )
}

///|
pub fn fixture_stripe_006() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-006",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"006\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-006"),
      ("stripe-signature", "t=fixture,v1=fixture-006"),
    ]),
  )
}

///|
pub fn fixture_stripe_007() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-007",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"007\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-007"),
      ("stripe-signature", "t=fixture,v1=fixture-007"),
    ]),
  )
}

///|
pub fn fixture_stripe_008() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-008",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"008\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-008"),
      ("stripe-signature", "t=fixture,v1=fixture-008"),
    ]),
  )
}

///|
pub fn fixture_stripe_009() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-009",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"009\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-009"),
      ("stripe-signature", "t=fixture,v1=fixture-009"),
    ]),
  )
}

///|
pub fn fixture_stripe_010() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-010",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"010\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-010"),
      ("stripe-signature", "t=fixture,v1=fixture-010"),
    ]),
  )
}

///|
pub fn fixture_stripe_011() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-011",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"011\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-011"),
      ("stripe-signature", "t=fixture,v1=fixture-011"),
    ]),
  )
}

///|
pub fn fixture_stripe_012() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-012",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"012\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-012"),
      ("stripe-signature", "t=fixture,v1=fixture-012"),
    ]),
  )
}

///|
pub fn fixture_stripe_013() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-013",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"013\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-013"),
      ("stripe-signature", "t=fixture,v1=fixture-013"),
    ]),
  )
}

///|
pub fn fixture_stripe_014() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-014",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"014\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-014"),
      ("stripe-signature", "t=fixture,v1=fixture-014"),
    ]),
  )
}

///|
pub fn fixture_stripe_015() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-015",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"015\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-015"),
      ("stripe-signature", "t=fixture,v1=fixture-015"),
    ]),
  )
}

///|
pub fn fixture_stripe_016() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-016",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"016\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-016"),
      ("stripe-signature", "t=fixture,v1=fixture-016"),
    ]),
  )
}

///|
pub fn fixture_stripe_017() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-017",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"017\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-017"),
      ("stripe-signature", "t=fixture,v1=fixture-017"),
    ]),
  )
}

///|
pub fn fixture_stripe_018() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-018",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"018\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-018"),
      ("stripe-signature", "t=fixture,v1=fixture-018"),
    ]),
  )
}

///|
pub fn fixture_stripe_019() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-019",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"019\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-019"),
      ("stripe-signature", "t=fixture,v1=fixture-019"),
    ]),
  )
}

///|
pub fn fixture_stripe_020() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-020",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"020\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-020"),
      ("stripe-signature", "t=fixture,v1=fixture-020"),
    ]),
  )
}

///|
pub fn fixture_stripe_021() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-021",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"021\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-021"),
      ("stripe-signature", "t=fixture,v1=fixture-021"),
    ]),
  )
}

///|
pub fn fixture_stripe_022() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-022",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"022\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-022"),
      ("stripe-signature", "t=fixture,v1=fixture-022"),
    ]),
  )
}

///|
pub fn fixture_stripe_023() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-023",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"023\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-023"),
      ("stripe-signature", "t=fixture,v1=fixture-023"),
    ]),
  )
}

///|
pub fn fixture_stripe_024() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-024",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"024\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-024"),
      ("stripe-signature", "t=fixture,v1=fixture-024"),
    ]),
  )
}

///|
pub fn fixture_stripe_025() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-025",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"025\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-025"),
      ("stripe-signature", "t=fixture,v1=fixture-025"),
    ]),
  )
}

///|
pub fn fixture_stripe_026() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-026",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"026\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-026"),
      ("stripe-signature", "t=fixture,v1=fixture-026"),
    ]),
  )
}

///|
pub fn fixture_stripe_027() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-027",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"027\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-027"),
      ("stripe-signature", "t=fixture,v1=fixture-027"),
    ]),
  )
}

///|
pub fn fixture_stripe_028() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-028",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"028\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-028"),
      ("stripe-signature", "t=fixture,v1=fixture-028"),
    ]),
  )
}

///|
pub fn fixture_stripe_029() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-029",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"029\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-029"),
      ("stripe-signature", "t=fixture,v1=fixture-029"),
    ]),
  )
}

///|
pub fn fixture_stripe_030() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-030",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"030\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-030"),
      ("stripe-signature", "t=fixture,v1=fixture-030"),
    ]),
  )
}

///|
pub fn fixture_stripe_031() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-031",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"031\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-031"),
      ("stripe-signature", "t=fixture,v1=fixture-031"),
    ]),
  )
}

///|
pub fn fixture_stripe_032() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-032",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"032\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-032"),
      ("stripe-signature", "t=fixture,v1=fixture-032"),
    ]),
  )
}

///|
pub fn fixture_stripe_033() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-033",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"033\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-033"),
      ("stripe-signature", "t=fixture,v1=fixture-033"),
    ]),
  )
}

///|
pub fn fixture_stripe_034() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-034",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"034\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-034"),
      ("stripe-signature", "t=fixture,v1=fixture-034"),
    ]),
  )
}

///|
pub fn fixture_stripe_035() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-035",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"035\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-035"),
      ("stripe-signature", "t=fixture,v1=fixture-035"),
    ]),
  )
}

///|
pub fn fixture_stripe_036() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-036",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"036\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-036"),
      ("stripe-signature", "t=fixture,v1=fixture-036"),
    ]),
  )
}

///|
pub fn fixture_stripe_037() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-037",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"037\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-037"),
      ("stripe-signature", "t=fixture,v1=fixture-037"),
    ]),
  )
}

///|
pub fn fixture_stripe_038() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-038",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"038\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-038"),
      ("stripe-signature", "t=fixture,v1=fixture-038"),
    ]),
  )
}

///|
pub fn fixture_stripe_039() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-039",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"039\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-039"),
      ("stripe-signature", "t=fixture,v1=fixture-039"),
    ]),
  )
}

///|
pub fn fixture_stripe_040() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-040",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"040\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-040"),
      ("stripe-signature", "t=fixture,v1=fixture-040"),
    ]),
  )
}

///|
pub fn fixture_stripe_041() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-041",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"041\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-041"),
      ("stripe-signature", "t=fixture,v1=fixture-041"),
    ]),
  )
}

///|
pub fn fixture_stripe_042() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-042",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"042\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-042"),
      ("stripe-signature", "t=fixture,v1=fixture-042"),
    ]),
  )
}

///|
pub fn fixture_stripe_043() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-043",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"043\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-043"),
      ("stripe-signature", "t=fixture,v1=fixture-043"),
    ]),
  )
}

///|
pub fn fixture_stripe_044() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-044",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"044\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-044"),
      ("stripe-signature", "t=fixture,v1=fixture-044"),
    ]),
  )
}

///|
pub fn fixture_stripe_045() -> HookRequest {
  HookRequest(
    Stripe,
    "checkout.session.completed",
    "stripe-delivery-045",
    "{\"provider\":\"stripe\",\"event\":\"checkout.session.completed\",\"index\":\"045\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "checkout.session.completed"),
      ("stripe-request-id", "stripe-delivery-045"),
      ("stripe-signature", "t=fixture,v1=fixture-045"),
    ]),
  )
}

///|
pub fn fixture_stripe_046() -> HookRequest {
  HookRequest(
    Stripe,
    "invoice.paid",
    "stripe-delivery-046",
    "{\"provider\":\"stripe\",\"event\":\"invoice.paid\",\"index\":\"046\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "invoice.paid"),
      ("stripe-request-id", "stripe-delivery-046"),
      ("stripe-signature", "t=fixture,v1=fixture-046"),
    ]),
  )
}

///|
pub fn fixture_stripe_047() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.created",
    "stripe-delivery-047",
    "{\"provider\":\"stripe\",\"event\":\"customer.created\",\"index\":\"047\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.created"),
      ("stripe-request-id", "stripe-delivery-047"),
      ("stripe-signature", "t=fixture,v1=fixture-047"),
    ]),
  )
}

///|
pub fn fixture_stripe_048() -> HookRequest {
  HookRequest(
    Stripe,
    "customer.updated",
    "stripe-delivery-048",
    "{\"provider\":\"stripe\",\"event\":\"customer.updated\",\"index\":\"048\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "customer.updated"),
      ("stripe-request-id", "stripe-delivery-048"),
      ("stripe-signature", "t=fixture,v1=fixture-048"),
    ]),
  )
}

///|
pub fn fixture_stripe_049() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.succeeded",
    "stripe-delivery-049",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.succeeded\",\"index\":\"049\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.succeeded"),
      ("stripe-request-id", "stripe-delivery-049"),
      ("stripe-signature", "t=fixture,v1=fixture-049"),
    ]),
  )
}

///|
pub fn fixture_stripe_050() -> HookRequest {
  HookRequest(
    Stripe,
    "payment_intent.payment_failed",
    "stripe-delivery-050",
    "{\"provider\":\"stripe\",\"event\":\"payment_intent.payment_failed\",\"index\":\"050\"}",
    timestamp="2026-08-08T00:00:00Z",
    headers=Map([
      ("stripe-event-type", "payment_intent.payment_failed"),
      ("stripe-request-id", "stripe-delivery-050"),
      ("stripe-signature", "t=fixture,v1=fixture-050"),
    ]),
  )
}

///|
/// Return one representative fixture for each built-in provider.
pub fn representative_fixtures() -> Array[HookRequest] {
  [
    fixture_github_001(),
    fixture_gitlab_001(),
    fixture_gitee_001(),
    fixture_feishu_001(),
    fixture_wecom_001(),
    fixture_stripe_001(),
  ]
}

///|
/// Return all generated fixtures. This is intentionally explicit so coverage
/// tools and docs can point to stable function names.
pub fn all_generated_fixtures() -> Array[HookRequest] {
  [
    fixture_github_001(),
    fixture_github_002(),
    fixture_github_003(),
    fixture_github_004(),
    fixture_github_005(),
    fixture_github_006(),
    fixture_github_007(),
    fixture_github_008(),
    fixture_github_009(),
    fixture_github_010(),
    fixture_github_011(),
    fixture_github_012(),
    fixture_github_013(),
    fixture_github_014(),
    fixture_github_015(),
    fixture_github_016(),
    fixture_github_017(),
    fixture_github_018(),
    fixture_github_019(),
    fixture_github_020(),
    fixture_github_021(),
    fixture_github_022(),
    fixture_github_023(),
    fixture_github_024(),
    fixture_github_025(),
    fixture_github_026(),
    fixture_github_027(),
    fixture_github_028(),
    fixture_github_029(),
    fixture_github_030(),
    fixture_github_031(),
    fixture_github_032(),
    fixture_github_033(),
    fixture_github_034(),
    fixture_github_035(),
    fixture_github_036(),
    fixture_github_037(),
    fixture_github_038(),
    fixture_github_039(),
    fixture_github_040(),
    fixture_github_041(),
    fixture_github_042(),
    fixture_github_043(),
    fixture_github_044(),
    fixture_github_045(),
    fixture_github_046(),
    fixture_github_047(),
    fixture_github_048(),
    fixture_github_049(),
    fixture_github_050(),
    fixture_gitlab_001(),
    fixture_gitlab_002(),
    fixture_gitlab_003(),
    fixture_gitlab_004(),
    fixture_gitlab_005(),
    fixture_gitlab_006(),
    fixture_gitlab_007(),
    fixture_gitlab_008(),
    fixture_gitlab_009(),
    fixture_gitlab_010(),
    fixture_gitlab_011(),
    fixture_gitlab_012(),
    fixture_gitlab_013(),
    fixture_gitlab_014(),
    fixture_gitlab_015(),
    fixture_gitlab_016(),
    fixture_gitlab_017(),
    fixture_gitlab_018(),
    fixture_gitlab_019(),
    fixture_gitlab_020(),
    fixture_gitlab_021(),
    fixture_gitlab_022(),
    fixture_gitlab_023(),
    fixture_gitlab_024(),
    fixture_gitlab_025(),
    fixture_gitlab_026(),
    fixture_gitlab_027(),
    fixture_gitlab_028(),
    fixture_gitlab_029(),
    fixture_gitlab_030(),
    fixture_gitlab_031(),
    fixture_gitlab_032(),
    fixture_gitlab_033(),
    fixture_gitlab_034(),
    fixture_gitlab_035(),
    fixture_gitlab_036(),
    fixture_gitlab_037(),
    fixture_gitlab_038(),
    fixture_gitlab_039(),
    fixture_gitlab_040(),
    fixture_gitlab_041(),
    fixture_gitlab_042(),
    fixture_gitlab_043(),
    fixture_gitlab_044(),
    fixture_gitlab_045(),
    fixture_gitlab_046(),
    fixture_gitlab_047(),
    fixture_gitlab_048(),
    fixture_gitlab_049(),
    fixture_gitlab_050(),
    fixture_gitee_001(),
    fixture_gitee_002(),
    fixture_gitee_003(),
    fixture_gitee_004(),
    fixture_gitee_005(),
    fixture_gitee_006(),
    fixture_gitee_007(),
    fixture_gitee_008(),
    fixture_gitee_009(),
    fixture_gitee_010(),
    fixture_gitee_011(),
    fixture_gitee_012(),
    fixture_gitee_013(),
    fixture_gitee_014(),
    fixture_gitee_015(),
    fixture_gitee_016(),
    fixture_gitee_017(),
    fixture_gitee_018(),
    fixture_gitee_019(),
    fixture_gitee_020(),
    fixture_gitee_021(),
    fixture_gitee_022(),
    fixture_gitee_023(),
    fixture_gitee_024(),
    fixture_gitee_025(),
    fixture_gitee_026(),
    fixture_gitee_027(),
    fixture_gitee_028(),
    fixture_gitee_029(),
    fixture_gitee_030(),
    fixture_gitee_031(),
    fixture_gitee_032(),
    fixture_gitee_033(),
    fixture_gitee_034(),
    fixture_gitee_035(),
    fixture_gitee_036(),
    fixture_gitee_037(),
    fixture_gitee_038(),
    fixture_gitee_039(),
    fixture_gitee_040(),
    fixture_gitee_041(),
    fixture_gitee_042(),
    fixture_gitee_043(),
    fixture_gitee_044(),
    fixture_gitee_045(),
    fixture_gitee_046(),
    fixture_gitee_047(),
    fixture_gitee_048(),
    fixture_gitee_049(),
    fixture_gitee_050(),
    fixture_feishu_001(),
    fixture_feishu_002(),
    fixture_feishu_003(),
    fixture_feishu_004(),
    fixture_feishu_005(),
    fixture_feishu_006(),
    fixture_feishu_007(),
    fixture_feishu_008(),
    fixture_feishu_009(),
    fixture_feishu_010(),
    fixture_feishu_011(),
    fixture_feishu_012(),
    fixture_feishu_013(),
    fixture_feishu_014(),
    fixture_feishu_015(),
    fixture_feishu_016(),
    fixture_feishu_017(),
    fixture_feishu_018(),
    fixture_feishu_019(),
    fixture_feishu_020(),
    fixture_feishu_021(),
    fixture_feishu_022(),
    fixture_feishu_023(),
    fixture_feishu_024(),
    fixture_feishu_025(),
    fixture_feishu_026(),
    fixture_feishu_027(),
    fixture_feishu_028(),
    fixture_feishu_029(),
    fixture_feishu_030(),
    fixture_feishu_031(),
    fixture_feishu_032(),
    fixture_feishu_033(),
    fixture_feishu_034(),
    fixture_feishu_035(),
    fixture_feishu_036(),
    fixture_feishu_037(),
    fixture_feishu_038(),
    fixture_feishu_039(),
    fixture_feishu_040(),
    fixture_feishu_041(),
    fixture_feishu_042(),
    fixture_feishu_043(),
    fixture_feishu_044(),
    fixture_feishu_045(),
    fixture_feishu_046(),
    fixture_feishu_047(),
    fixture_feishu_048(),
    fixture_feishu_049(),
    fixture_feishu_050(),
    fixture_wecom_001(),
    fixture_wecom_002(),
    fixture_wecom_003(),
    fixture_wecom_004(),
    fixture_wecom_005(),
    fixture_wecom_006(),
    fixture_wecom_007(),
    fixture_wecom_008(),
    fixture_wecom_009(),
    fixture_wecom_010(),
    fixture_wecom_011(),
    fixture_wecom_012(),
    fixture_wecom_013(),
    fixture_wecom_014(),
    fixture_wecom_015(),
    fixture_wecom_016(),
    fixture_wecom_017(),
    fixture_wecom_018(),
    fixture_wecom_019(),
    fixture_wecom_020(),
    fixture_wecom_021(),
    fixture_wecom_022(),
    fixture_wecom_023(),
    fixture_wecom_024(),
    fixture_wecom_025(),
    fixture_wecom_026(),
    fixture_wecom_027(),
    fixture_wecom_028(),
    fixture_wecom_029(),
    fixture_wecom_030(),
    fixture_wecom_031(),
    fixture_wecom_032(),
    fixture_wecom_033(),
    fixture_wecom_034(),
    fixture_wecom_035(),
    fixture_wecom_036(),
    fixture_wecom_037(),
    fixture_wecom_038(),
    fixture_wecom_039(),
    fixture_wecom_040(),
    fixture_wecom_041(),
    fixture_wecom_042(),
    fixture_wecom_043(),
    fixture_wecom_044(),
    fixture_wecom_045(),
    fixture_wecom_046(),
    fixture_wecom_047(),
    fixture_wecom_048(),
    fixture_wecom_049(),
    fixture_wecom_050(),
    fixture_stripe_001(),
    fixture_stripe_002(),
    fixture_stripe_003(),
    fixture_stripe_004(),
    fixture_stripe_005(),
    fixture_stripe_006(),
    fixture_stripe_007(),
    fixture_stripe_008(),
    fixture_stripe_009(),
    fixture_stripe_010(),
    fixture_stripe_011(),
    fixture_stripe_012(),
    fixture_stripe_013(),
    fixture_stripe_014(),
    fixture_stripe_015(),
    fixture_stripe_016(),
    fixture_stripe_017(),
    fixture_stripe_018(),
    fixture_stripe_019(),
    fixture_stripe_020(),
    fixture_stripe_021(),
    fixture_stripe_022(),
    fixture_stripe_023(),
    fixture_stripe_024(),
    fixture_stripe_025(),
    fixture_stripe_026(),
    fixture_stripe_027(),
    fixture_stripe_028(),
    fixture_stripe_029(),
    fixture_stripe_030(),
    fixture_stripe_031(),
    fixture_stripe_032(),
    fixture_stripe_033(),
    fixture_stripe_034(),
    fixture_stripe_035(),
    fixture_stripe_036(),
    fixture_stripe_037(),
    fixture_stripe_038(),
    fixture_stripe_039(),
    fixture_stripe_040(),
    fixture_stripe_041(),
    fixture_stripe_042(),
    fixture_stripe_043(),
    fixture_stripe_044(),
    fixture_stripe_045(),
    fixture_stripe_046(),
    fixture_stripe_047(),
    fixture_stripe_048(),
    fixture_stripe_049(),
    fixture_stripe_050(),
  ]
}