Revost Admin API

curl -X GET "http://localhost:8081/api/v1/health"

const response = await fetch("http://localhost:8081/api/v1/health", {
  method: "GET",
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/admin-users/me" \
  -H "Authorization: Bearer <token>"

{
  "admin_user": {
    "id": "string",
    "firebase_uid": "string",
    "name": "string"
  }
}

const response = await fetch("http://localhost:8081/api/v1/admin-users/me", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/admin-users/me" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/admin-users/me", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string"
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts" \
  -H "Authorization: Bearer <token>"

{
  "gifts": [
    {
      "id": "string",
      "name": "string",
      "image_url": "https://example.com",
      "type": "string",
      "base_coin_cost": 0,
      "is_active": true,
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ],
  "total_count": 0
}

const response = await fetch("http://localhost:8081/api/v1/gifts", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "image_url": "https://example.com",
  "type": "string",
  "base_coin_cost": 0,
  "return_rate": 0,
  "is_active": true
}'

const response = await fetch("http://localhost:8081/api/v1/gifts", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "image_url": "https://example.com",
  "type": "string",
  "base_coin_cost": 0,
  "return_rate": 0,
  "is_active": true
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts/{gift_id}" \
  -H "Authorization: Bearer <token>"

{
  "id": "string",
  "name": "string",
  "image_url": "https://example.com",
  "type": "string",
  "base_coin_cost": 0,
  "is_active": true,
  "created_at": "2024-01-01T00:00:00Z",
  "updated_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X PATCH "http://localhost:8081/api/v1/gifts/{gift_id}" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "image_url": "https://example.com",
  "type": "string",
  "base_coin_cost": 0,
  "return_rate": 0,
  "is_active": true
}'

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "image_url": "https://example.com",
  "type": "string",
  "base_coin_cost": 0,
  "return_rate": 0,
  "is_active": true
})
});

const data = await response.json();

curl -X DELETE "http://localhost:8081/api/v1/gifts/{gift_id}" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}", {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts/{gift_id}/versions" \
  -H "Authorization: Bearer <token>"

{
  "versions": [
    {
      "id": "string",
      "gift_id": "string",
      "name": "string",
      "image_url": "https://example.com",
      "status": "string",
      "activated_at": "2024-01-01T00:00:00Z",
      "retired_at": "2024-01-01T00:00:00Z",
      "created_by_admin_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ]
}

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/versions", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/versions" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "image_url": "https://example.com"
}'

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/versions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "image_url": "https://example.com"
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts/{gift_id}/versions/{version_id}" \
  -H "Authorization: Bearer <token>"

{
  "id": "string",
  "gift_id": "string",
  "name": "string",
  "image_url": "https://example.com",
  "status": "string",
  "activated_at": "2024-01-01T00:00:00Z",
  "retired_at": "2024-01-01T00:00:00Z",
  "created_by_admin_id": "string",
  "created_at": "2024-01-01T00:00:00Z",
  "updated_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/versions/{version_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/versions/{version_id}/activate" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/versions/{version_id}/activate", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/versions/{version_id}/retire" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/versions/{version_id}/retire", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts/{gift_id}/price-versions" \
  -H "Authorization: Bearer <token>"

{
  "versions": [
    {
      "id": "string",
      "gift_id": "string",
      "base_coin_cost": 0,
      "status": "string",
      "activated_at": "2024-01-01T00:00:00Z",
      "retired_at": "2024-01-01T00:00:00Z",
      "created_by_admin_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ]
}

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/price-versions", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/price-versions" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "base_coin_cost": 0
}'

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/price-versions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "base_coin_cost": 0
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts/{gift_id}/price-versions/{version_id}" \
  -H "Authorization: Bearer <token>"

{
  "id": "string",
  "gift_id": "string",
  "base_coin_cost": 0,
  "status": "string",
  "activated_at": "2024-01-01T00:00:00Z",
  "retired_at": "2024-01-01T00:00:00Z",
  "created_by_admin_id": "string",
  "created_at": "2024-01-01T00:00:00Z",
  "updated_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/price-versions/{version_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/price-versions/{version_id}/activate" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/price-versions/{version_id}/activate", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/price-versions/{version_id}/retire" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/price-versions/{version_id}/retire", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions" \
  -H "Authorization: Bearer <token>"

{
  "versions": [
    {
      "id": "string",
      "gift_id": "string",
      "reward_type": null,
      "return_rate": 0,
      "random_draw_table_version_id": "string",
      "status": "string",
      "activated_at": "2024-01-01T00:00:00Z",
      "retired_at": "2024-01-01T00:00:00Z",
      "created_by_admin_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ]
}

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d 'null'

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify(null)
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions/{version_id}" \
  -H "Authorization: Bearer <token>"

{
  "id": "string",
  "gift_id": "string",
  "reward_type": null,
  "return_rate": 0,
  "random_draw_table_version_id": "string",
  "status": "string",
  "activated_at": "2024-01-01T00:00:00Z",
  "retired_at": "2024-01-01T00:00:00Z",
  "created_by_admin_id": "string",
  "created_at": "2024-01-01T00:00:00Z",
  "updated_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions/{version_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions/{version_id}/activate" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions/{version_id}/activate", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions/{version_id}/retire" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/gifts/{gift_id}/reward-rule-versions/{version_id}/retire", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/random-draw-tables" \
  -H "Authorization: Bearer <token>"

{
  "tables": [
    {
      "id": "string",
      "name": "string",
      "description": "string",
      "created_by_admin_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ],
  "total_count": 0
}

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/random-draw-tables" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "description": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "description": "string"
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/random-draw-tables/{table_id}" \
  -H "Authorization: Bearer <token>"

{
  "id": "string",
  "name": "string",
  "description": "string",
  "created_by_admin_id": "string",
  "created_at": "2024-01-01T00:00:00Z",
  "updated_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables/{table_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X PATCH "http://localhost:8081/api/v1/random-draw-tables/{table_id}" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "description": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables/{table_id}", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "description": "string"
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions" \
  -H "Authorization: Bearer <token>"

{
  "versions": [
    {
      "id": "string",
      "table_id": "string",
      "total_weight": 0,
      "status": "string",
      "items": [
        {
          "id": "string",
          "label": "string",
          "reward_coin_amount": 0,
          "weight": 0,
          "sort_order": 0
        }
      ],
      "activated_at": "2024-01-01T00:00:00Z",
      "retired_at": "2024-01-01T00:00:00Z",
      "created_by_admin_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ]
}

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "label": "string",
      "reward_coin_amount": 0,
      "weight": 0,
      "sort_order": 0
    }
  ]
}'

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "items": [
    {
      "label": "string",
      "reward_coin_amount": 0,
      "weight": 0,
      "sort_order": 0
    }
  ]
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions/{version_id}" \
  -H "Authorization: Bearer <token>"

{
  "id": "string",
  "table_id": "string",
  "total_weight": 0,
  "status": "string",
  "items": [
    {
      "id": "string",
      "label": "string",
      "reward_coin_amount": 0,
      "weight": 0,
      "sort_order": 0
    }
  ],
  "activated_at": "2024-01-01T00:00:00Z",
  "retired_at": "2024-01-01T00:00:00Z",
  "created_by_admin_id": "string",
  "created_at": "2024-01-01T00:00:00Z",
  "updated_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions/{version_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions/{version_id}/activate" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions/{version_id}/activate", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions/{version_id}/retire" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/random-draw-tables/{table_id}/versions/{version_id}/retire", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gacha-pools" \
  -H "Authorization: Bearer <token>"

{
  "pools": [
    {
      "pool_id": "string",
      "name": "string",
      "description": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "active_version": {}
    }
  ]
}

const response = await fetch("http://localhost:8081/api/v1/gacha-pools", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gacha-pools" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "description": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/gacha-pools", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "description": "string"
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gacha-pools/{pool_id}" \
  -H "Authorization: Bearer <token>"

{
  "pool_id": "string",
  "name": "string",
  "description": "string",
  "created_at": "2024-01-01T00:00:00Z",
  "versions": [
    {
      "version_id": "string",
      "status": "string",
      "coin_cost_per_pull": 0,
      "batch_coin_cost": 0,
      "batch_pull_count": 0,
      "activated_at": "2024-01-01T00:00:00Z",
      "retired_at": "2024-01-01T00:00:00Z",
      "created_at": "2024-01-01T00:00:00Z",
      "items": [
        {
          "item_id": "string",
          "reward_type": "GIFT_BAG_ITEM",
          "label": "string",
          "weight": 0,
          "sort_order": 0,
          "gift_id": "string",
          "gift_quantity": 0,
          "reward_expiry_days": 0,
          "coin_amount": 0
        }
      ]
    }
  ]
}

const response = await fetch("http://localhost:8081/api/v1/gacha-pools/{pool_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gacha-pools/{pool_id}/versions" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "coin_cost_per_pull": 0,
  "batch_coin_cost": 0,
  "batch_pull_count": 0,
  "items": [
    {
      "reward_type": "GIFT_BAG_ITEM",
      "label": "string",
      "weight": 0,
      "sort_order": 0,
      "gift_id": "string",
      "gift_quantity": 0,
      "reward_expiry_days": 0,
      "coin_amount": 0
    }
  ]
}'

const response = await fetch("http://localhost:8081/api/v1/gacha-pools/{pool_id}/versions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "coin_cost_per_pull": 0,
  "batch_coin_cost": 0,
  "batch_pull_count": 0,
  "items": [
    {
      "reward_type": "GIFT_BAG_ITEM",
      "label": "string",
      "weight": 0,
      "sort_order": 0,
      "gift_id": "string",
      "gift_quantity": 0,
      "reward_expiry_days": 0,
      "coin_amount": 0
    }
  ]
})
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gacha-pool-versions/{version_id}/activate" \
  -H "Authorization: Bearer <token>"

{
  "version_id": "string",
  "status": "string",
  "activated_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/gacha-pool-versions/{version_id}/activate", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gacha-pool-versions/{version_id}/retire" \
  -H "Authorization: Bearer <token>"

{
  "version_id": "string",
  "status": "string",
  "retired_at": "2024-01-01T00:00:00Z"
}

const response = await fetch("http://localhost:8081/api/v1/gacha-pool-versions/{version_id}/retire", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/campaigns" \
  -H "Authorization: Bearer <token>"

{
  "campaigns": [
    {
      "id": "string",
      "name": "string",
      "description": "string",
      "status": null,
      "start_at": "2024-01-01T00:00:00Z",
      "end_at": "2024-01-01T00:00:00Z",
      "budget_coin": 0,
      "granted_coin": 0,
      "per_user_limit_coin": 0,
      "coin_amount_per_grant": 0,
      "expires_in_days": 0,
      "admin_user_id": "string",
      "updated_by_admin_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ],
  "total_count": 0
}

const response = await fetch("http://localhost:8081/api/v1/campaigns", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/campaigns" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "description": "string",
  "start_at": "2024-01-01T00:00:00Z",
  "end_at": "2024-01-01T00:00:00Z",
  "budget_coin": 0,
  "per_user_limit_coin": 0,
  "coin_amount_per_grant": 0,
  "expires_in_days": 0
}'

const response = await fetch("http://localhost:8081/api/v1/campaigns", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "description": "string",
  "start_at": "2024-01-01T00:00:00Z",
  "end_at": "2024-01-01T00:00:00Z",
  "budget_coin": 0,
  "per_user_limit_coin": 0,
  "coin_amount_per_grant": 0,
  "expires_in_days": 0
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/campaigns/{campaign_id}" \
  -H "Authorization: Bearer <token>"

{
  "campaign": {
    "id": "string",
    "name": "string",
    "description": "string",
    "status": null,
    "start_at": "2024-01-01T00:00:00Z",
    "end_at": "2024-01-01T00:00:00Z",
    "budget_coin": 0,
    "granted_coin": 0,
    "per_user_limit_coin": 0,
    "coin_amount_per_grant": 0,
    "expires_in_days": 0,
    "admin_user_id": "string",
    "updated_by_admin_id": "string",
    "created_at": "2024-01-01T00:00:00Z",
    "updated_at": "2024-01-01T00:00:00Z"
  }
}

const response = await fetch("http://localhost:8081/api/v1/campaigns/{campaign_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X PATCH "http://localhost:8081/api/v1/campaigns/{campaign_id}" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "description": "string",
  "status": null,
  "start_at": "2024-01-01T00:00:00Z",
  "end_at": "2024-01-01T00:00:00Z",
  "budget_coin": 0,
  "per_user_limit_coin": 0,
  "coin_amount_per_grant": 0,
  "expires_in_days": 0
}'

const response = await fetch("http://localhost:8081/api/v1/campaigns/{campaign_id}", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "name": "string",
  "description": "string",
  "status": null,
  "start_at": "2024-01-01T00:00:00Z",
  "end_at": "2024-01-01T00:00:00Z",
  "budget_coin": 0,
  "per_user_limit_coin": 0,
  "coin_amount_per_grant": 0,
  "expires_in_days": 0
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/coin-adjustments" \
  -H "Authorization: Bearer <token>"

{
  "coin_adjustments": [
    {
      "id": "string",
      "user_id": "string",
      "admin_user_id": "string",
      "amount_coin": 0,
      "operation_type": "MANUAL_GRANT",
      "status": "succeeded",
      "campaign_id": "string",
      "reason_detail": "string",
      "idempotency_key": "string",
      "expires_at": "2024-01-01T00:00:00Z",
      "coin_transaction_id": "string",
      "balance_after_coin": 0,
      "processed_at": "2024-01-01T00:00:00Z",
      "created_at": "2024-01-01T00:00:00Z"
    }
  ],
  "next_cursor": "string"
}

const response = await fetch("http://localhost:8081/api/v1/coin-adjustments", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/coin-adjustments" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "user_id": "string",
  "amount_coin": 0,
  "operation_type": "MANUAL_GRANT",
  "campaign_id": "string",
  "reason_detail": "string",
  "expires_at": "2024-01-01T00:00:00Z"
}'

const response = await fetch("http://localhost:8081/api/v1/coin-adjustments", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "user_id": "string",
  "amount_coin": 0,
  "operation_type": "MANUAL_GRANT",
  "campaign_id": "string",
  "reason_detail": "string",
  "expires_at": "2024-01-01T00:00:00Z"
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/coin-adjustments/{adjustment_id}" \
  -H "Authorization: Bearer <token>"

{
  "coin_adjustment": {
    "id": "string",
    "user_id": "string",
    "admin_user_id": "string",
    "amount_coin": 0,
    "operation_type": "MANUAL_GRANT",
    "status": "succeeded",
    "campaign_id": "string",
    "reason_detail": "string",
    "idempotency_key": "string",
    "expires_at": "2024-01-01T00:00:00Z",
    "coin_transaction_id": "string",
    "balance_after_coin": 0,
    "processed_at": "2024-01-01T00:00:00Z",
    "created_at": "2024-01-01T00:00:00Z"
  }
}

const response = await fetch("http://localhost:8081/api/v1/coin-adjustments/{adjustment_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gift-bag-items" \
  -H "Authorization: Bearer <token>"

{
  "gift_bag_items": [
    {
      "id": "string",
      "user_id": "string",
      "gift_id": "string",
      "quantity": 0,
      "remaining_qty": 0,
      "source_type": "string",
      "expires_at": "2024-01-01T00:00:00Z",
      "granted_by_admin_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ],
  "next_cursor": "string"
}

const response = await fetch("http://localhost:8081/api/v1/gift-bag-items", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/gift-bag-items/{item_id}" \
  -H "Authorization: Bearer <token>"

{
  "gift_bag_item": {
    "id": "string",
    "user_id": "string",
    "gift_id": "string",
    "quantity": 0,
    "remaining_qty": 0,
    "source_type": "string",
    "expires_at": "2024-01-01T00:00:00Z",
    "granted_by_admin_id": "string",
    "created_at": "2024-01-01T00:00:00Z",
    "updated_at": "2024-01-01T00:00:00Z"
  }
}

const response = await fetch("http://localhost:8081/api/v1/gift-bag-items/{item_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/gift-bag-grants" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "user_id": "string",
  "gift_id": "string",
  "quantity": 0,
  "expires_at": "2024-01-01T00:00:00Z",
  "source_type": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/gift-bag-grants", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "user_id": "string",
  "gift_id": "string",
  "quantity": 0,
  "expires_at": "2024-01-01T00:00:00Z",
  "source_type": "string"
})
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/uploads/gift-image" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/uploads/gift-image", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/payment-refunds" \
  -H "Authorization: Bearer <token>"

{
  "refunds": [
    {
      "id": "string",
      "payment_id": "string",
      "source": "admin",
      "refund_type": "voluntary",
      "refund_scope": "full",
      "refund_reason": "string",
      "status": "pending",
      "refund_amount_money": 0,
      "refund_coin_amount": 0,
      "recovered_coin_amount": 0,
      "shortfall_coin_amount": 0,
      "recover_from_recipients": true,
      "last_error": "string",
      "requested_at": "2024-01-01T00:00:00Z",
      "processing_started_at": "2024-01-01T00:00:00Z",
      "processed_at": "2024-01-01T00:00:00Z",
      "admin_user_id": "string",
      "created_at": "2024-01-01T00:00:00Z",
      "recipient_recovery_targets": [
        {
          "id": "string",
          "payment_refund_id": "string",
          "gift_transaction_id": "string",
          "receiver_user_coin_account_id": "string",
          "target_coin_amount": 0,
          "recovered_coin_amount": 0,
          "shortfall_coin_amount": 0,
          "status": "pending",
          "decision_reason": "string",
          "evidence_note": "string",
          "decided_by_admin_user_id": "string",
          "processed_at": "2024-01-01T00:00:00Z",
          "created_at": "2024-01-01T00:00:00Z"
        }
      ]
    }
  ],
  "next_cursor": "string"
}

const response = await fetch("http://localhost:8081/api/v1/payment-refunds", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/payment-refunds" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "payment_id": "string",
  "refund_type": "voluntary",
  "refund_reason": "string",
  "refund_amount_money": 0,
  "refund_coin_amount": 0,
  "recover_from_recipients": true,
  "recipient_recovery_targets": [
    {
      "gift_transaction_id": "string",
      "receiver_user_coin_account_id": "string",
      "target_coin_amount": 0,
      "decision_reason": "string",
      "evidence_note": "string"
    }
  ]
}'

const response = await fetch("http://localhost:8081/api/v1/payment-refunds", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "payment_id": "string",
  "refund_type": "voluntary",
  "refund_reason": "string",
  "refund_amount_money": 0,
  "refund_coin_amount": 0,
  "recover_from_recipients": true,
  "recipient_recovery_targets": [
    {
      "gift_transaction_id": "string",
      "receiver_user_coin_account_id": "string",
      "target_coin_amount": 0,
      "decision_reason": "string",
      "evidence_note": "string"
    }
  ]
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/payment-refunds/{refund_id}" \
  -H "Authorization: Bearer <token>"

{
  "refund": {
    "id": "string",
    "payment_id": "string",
    "source": "admin",
    "refund_type": "voluntary",
    "refund_scope": "full",
    "refund_reason": "string",
    "status": "pending",
    "refund_amount_money": 0,
    "refund_coin_amount": 0,
    "recovered_coin_amount": 0,
    "shortfall_coin_amount": 0,
    "recover_from_recipients": true,
    "last_error": "string",
    "requested_at": "2024-01-01T00:00:00Z",
    "processing_started_at": "2024-01-01T00:00:00Z",
    "processed_at": "2024-01-01T00:00:00Z",
    "admin_user_id": "string",
    "created_at": "2024-01-01T00:00:00Z",
    "recipient_recovery_targets": [
      {
        "id": "string",
        "payment_refund_id": "string",
        "gift_transaction_id": "string",
        "receiver_user_coin_account_id": "string",
        "target_coin_amount": 0,
        "recovered_coin_amount": 0,
        "shortfall_coin_amount": 0,
        "status": "pending",
        "decision_reason": "string",
        "evidence_note": "string",
        "decided_by_admin_user_id": "string",
        "processed_at": "2024-01-01T00:00:00Z",
        "created_at": "2024-01-01T00:00:00Z"
      }
    ]
  }
}

const response = await fetch("http://localhost:8081/api/v1/payment-refunds/{refund_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/payment-refunds/{refund_id}/execute" \
  -H "Authorization: Bearer <token>"

{
  "refund_id": "string",
  "status": "pending"
}

const response = await fetch("http://localhost:8081/api/v1/payment-refunds/{refund_id}/execute", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/payment-refunds/{refund_id}/fail" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "reason": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/payment-refunds/{refund_id}/fail", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "reason": "string"
})
});

const data = await response.json();

curl -X PUT "http://localhost:8081/api/v1/payment-refunds/{refund_id}/recipient-recovery-targets" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "recipient_recovery_targets": [
    {
      "gift_transaction_id": "string",
      "receiver_user_coin_account_id": "string",
      "target_coin_amount": 0,
      "decision_reason": "string",
      "evidence_note": "string"
    }
  ]
}'

{
  "refund_id": "string",
  "recover_from_recipients": true,
  "target_count": 0
}

const response = await fetch("http://localhost:8081/api/v1/payment-refunds/{refund_id}/recipient-recovery-targets", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "recipient_recovery_targets": [
    {
      "gift_transaction_id": "string",
      "receiver_user_coin_account_id": "string",
      "target_coin_amount": 0,
      "decision_reason": "string",
      "evidence_note": "string"
    }
  ]
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/debts" \
  -H "Authorization: Bearer <token>"

{
  "users": [
    {
      "user_id": "string",
      "amount_coin": 0,
      "updated_at": "2024-01-01T00:00:00Z"
    }
  ],
  "next_cursor": "string"
}

const response = await fetch("http://localhost:8081/api/v1/debts", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/debts/cases/{debt_case_id}/settle" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "amount_coin": 0,
  "reason": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/debts/cases/{debt_case_id}/settle", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "amount_coin": 0,
  "reason": "string"
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/debts/{user_id}" \
  -H "Authorization: Bearer <token>"

{
  "debt_cases": [
    {
      "id": "string",
      "reason": "string",
      "reference_type": "string",
      "reference_id": "string",
      "original_amount_coin": 0,
      "outstanding_coin": 0,
      "status": null,
      "created_at": "2024-01-01T00:00:00Z",
      "settled_at": "2024-01-01T00:00:00Z"
    }
  ],
  "next_cursor": "string"
}

const response = await fetch("http://localhost:8081/api/v1/debts/{user_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/withdrawals" \
  -H "Authorization: Bearer <token>"

{
  "withdrawals": [
    {
      "id": "string",
      "user_id": "string",
      "year_month": "string",
      "amount_coin": 0,
      "gross_amount_yen": 0,
      "fee_amount_yen": 0,
      "net_amount_yen": 0,
      "status": null,
      "created_at": "2024-01-01T00:00:00Z",
      "paid_at": "2024-01-01T00:00:00Z"
    }
  ],
  "next_cursor": "string"
}

const response = await fetch("http://localhost:8081/api/v1/withdrawals", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/withdrawals/{withdrawal_id}" \
  -H "Authorization: Bearer <token>"

{
  "withdrawal": {
    "id": "string",
    "user_id": "string",
    "year_month": "string",
    "amount_coin": 0,
    "gross_amount_yen": 0,
    "fee_amount_yen": 0,
    "net_amount_yen": 0,
    "status": null,
    "created_at": "2024-01-01T00:00:00Z",
    "paid_at": "2024-01-01T00:00:00Z"
  }
}

const response = await fetch("http://localhost:8081/api/v1/withdrawals/{withdrawal_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/approve" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/approve", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/cancel" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/cancel", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/fail" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "reason": "string"
}'

const response = await fetch("http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/fail", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "reason": "string"
})
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/pay" \
  -H "Authorization: Bearer <token>"

const response = await fetch("http://localhost:8081/api/v1/withdrawals/{withdrawal_id}/pay", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/iap-products" \
  -H "Authorization: Bearer <token>"

{
  "iap_products": [
    {
      "id": "string",
      "store_product_id": "string",
      "platform": "string",
      "product_type": "string",
      "coin_amount": 0,
      "is_active": true,
      "created_at": "2024-01-01T00:00:00Z"
    }
  ],
  "total_count": 0
}

const response = await fetch("http://localhost:8081/api/v1/iap-products", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X POST "http://localhost:8081/api/v1/iap-products" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "store_product_id": "string",
  "platform": "string",
  "product_type": "string",
  "coin_amount": 0,
  "is_active": true
}'

const response = await fetch("http://localhost:8081/api/v1/iap-products", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "store_product_id": "string",
  "platform": "string",
  "product_type": "string",
  "coin_amount": 0,
  "is_active": true
})
});

const data = await response.json();

curl -X GET "http://localhost:8081/api/v1/iap-products/{iap_product_id}" \
  -H "Authorization: Bearer <token>"

{
  "iap_product": null
}

const response = await fetch("http://localhost:8081/api/v1/iap-products/{iap_product_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();

curl -X PATCH "http://localhost:8081/api/v1/iap-products/{iap_product_id}" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
  "platform": "string",
  "store_product_id": "string",
  "product_type": "string",
  "coin_amount": 0,
  "is_active": true
}'

const response = await fetch("http://localhost:8081/api/v1/iap-products/{iap_product_id}", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "platform": "string",
  "store_product_id": "string",
  "product_type": "string",
  "coin_amount": 0,
  "is_active": true
})
});

const data = await response.json();